pdfkit
Version:
A JavaScript PDF generation library
33,797 lines • 1.42 MB
JavaScript
(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.PDFDocument = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
(function (__filename){(function (){
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var utils = require('@noble/hashes/utils');
var fflate = require('fflate');
var aes = require('@noble/ciphers/aes');
var fontkit = require('fontkit');
var LineBreaker = require('linebreak');
var PNG = require('png-js');
var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
class EventEmitter {
constructor() {
this._listeners = Object.create(null);
}
on(event, listener) {
(this._listeners[event] || (this._listeners[event] = [])).push(listener);
return this;
}
once(event, listener) {
const wrapper = (...args) => {
this.off(event, wrapper);
listener(...args);
};
return this.on(event, wrapper);
}
off(event, listener) {
const listeners = this._listeners[event];
if (listeners) {
const index = listeners.indexOf(listener);
if (index !== -1) listeners.splice(index, 1);
}
return this;
}
emit(event, ...args) {
const listeners = this._listeners[event];
if (!listeners) return false;
for (const listener of listeners.slice()) listener(...args);
return listeners.length > 0;
}
}
class Readable extends EventEmitter {
constructor() {
super();
this._buffer = [];
this._flowing = false;
this._scheduled = false;
this._finished = false;
this._endEmitted = false;
}
on(event, listener) {
super.on(event, listener);
if (event === 'data') this.resume();
return this;
}
push(chunk) {
if (chunk === null) {
this._finished = true;
} else {
this._buffer.push(chunk);
}
this._schedule();
return true;
}
resume() {
this._flowing = true;
this._schedule();
return this;
}
pause() {
this._flowing = false;
return this;
}
pipe(destination) {
this.on('data', chunk => {
if (destination.write(chunk) === false) {
this.pause();
destination.once('drain', () => this.resume());
}
});
this.on('end', () => destination.end());
return destination;
}
_schedule() {
if (this._scheduled || !this._flowing) return;
this._scheduled = true;
queueMicrotask(() => {
this._scheduled = false;
this._drain();
});
}
_drain() {
while (this._flowing && this._buffer.length > 0) {
this.emit('data', this._buffer.shift());
}
if (this._flowing && this._finished && !this._endEmitted) {
this._endEmitted = true;
this.emit('end');
}
}
async *[Symbol.asyncIterator]() {
const chunks = [];
let ended = false;
let notify = null;
const wake = () => {
const resolve = notify;
notify = null;
if (resolve) resolve();
};
this.on('data', chunk => {
chunks.push(chunk);
wake();
});
this.on('end', () => {
ended = true;
wake();
});
for (;;) {
while (chunks.length > 0) yield chunks.shift();
if (ended) return;
await new Promise(resolve => {
notify = resolve;
});
}
}
}
class PDFAbstractReference {
toString() {
throw new Error('Must be implemented by subclasses');
}
}
class PDFTree {
constructor(options = {}) {
this._items = {};
this.limits = typeof options.limits === 'boolean' ? options.limits : true;
}
add(key, val) {
return this._items[key] = val;
}
get(key) {
return this._items[key];
}
toString() {
const sortedKeys = Object.keys(this._items).sort((a, b) => this._compareKeys(a, b));
const out = ['<<'];
if (this.limits && sortedKeys.length > 1) {
const first = sortedKeys[0],
last = sortedKeys[sortedKeys.length - 1];
out.push(` /Limits ${PDFObject.convert([this._dataForKey(first), this._dataForKey(last)])}`);
}
out.push(` /${this._keysName()} [`);
for (let key of sortedKeys) {
out.push(` ${PDFObject.convert(this._dataForKey(key))} ${PDFObject.convert(this._items[key])}`);
}
out.push(']');
out.push('>>');
return out.join('\n');
}
_compareKeys() {
throw new Error('Must be implemented by subclasses');
}
_keysName() {
throw new Error('Must be implemented by subclasses');
}
_dataForKey() {
throw new Error('Must be implemented by subclasses');
}
}
class SpotColor {
constructor(doc, name, C, M, Y, K) {
this.id = 'CS' + Object.keys(doc.spotColors).length;
this.name = name;
this.values = [C, M, Y, K];
this.ref = doc.ref(['Separation', escapeName(this.name), 'DeviceCMYK', {
Range: [0, 1, 0, 1, 0, 1, 0, 1],
C0: [0, 0, 0, 0],
C1: this.values.map(value => value / 100),
FunctionType: 2,
Domain: [0, 1],
N: 1
}]);
this.ref.end();
}
toString() {
return `${this.ref.id} 0 R`;
}
}
const toBinaryString = bytes => {
const chunkSize = 0x8000;
let out = '';
for (let i = 0; i < bytes.length; i += chunkSize) {
const end = Math.min(i + chunkSize, bytes.length);
out += String.fromCharCode.apply(null, bytes.subarray(i, end));
}
return out;
};
const fromBinaryString = str => {
const out = new Uint8Array(str.length);
for (let i = 0; i < str.length; i++) {
out[i] = str.charCodeAt(i) & 0xff;
}
return out;
};
const fromBase64 = b64 => {
const binary = atob(b64);
const out = new Uint8Array(binary.length);
for (let i = 0; i < binary.length; i++) {
out[i] = binary.charCodeAt(i);
}
return out;
};
const concat = chunks => {
let length = 0;
for (const chunk of chunks) length += chunk.length;
const out = new Uint8Array(length);
let offset = 0;
for (const chunk of chunks) {
out.set(chunk, offset);
offset += chunk.length;
}
return out;
};
const toUTF16BE = str => {
const out = new Uint8Array((str.length + 1) * 2);
out[0] = 0xfe;
out[1] = 0xff;
for (let i = 0; i < str.length; i++) {
const code = str.charCodeAt(i);
out[i * 2 + 2] = code >> 8;
out[i * 2 + 3] = code & 0xff;
}
return out;
};
const readUInt16BE = (bytes, offset = 0) => (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
const readUInt16LE = (bytes, offset = 0) => (bytes[offset + 1] << 8 | bytes[offset]) >>> 0;
const readUInt32BE = (bytes, offset = 0) => bytes[offset] * 0x1000000 + (bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
const readUInt32LE = (bytes, offset = 0) => (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16) + bytes[offset + 3] * 0x1000000 >>> 0;
const pad = (str, length) => (Array(length + 1).join('0') + str).slice(-length);
const isSafeCharCode = code => {
if (code > 0x7f) return true;
return code > 0x20 && code !== 0x7f && code !== 0x23 && code !== 0x25 && code !== 0x28 && code !== 0x29 && code !== 0x2f && code !== 0x3c && code !== 0x3e && code !== 0x5b && code !== 0x5d && code !== 0x7b && code !== 0x7d;
};
const escapableRe = /[\n\r\t\b\f()\\]/g;
const escapable = {
'\n': '\\n',
'\r': '\\r',
'\t': '\\t',
'\b': '\\b',
'\f': '\\f',
'\\': '\\\\',
'(': '\\(',
')': '\\)'
};
const escapeName = function (name) {
let escapedName = '';
for (const char of name) {
const code = char.charCodeAt(0);
if (isSafeCharCode(code)) {
escapedName += char;
} else {
escapedName += `#${code.toString(16).toUpperCase().padStart(2, '0')}`;
}
}
return escapedName;
};
class PDFObject {
static convert(object, encryptFn = null) {
if (typeof object === 'string') {
return `/${object}`;
} else if (object instanceof String) {
let string = object;
let isUnicode = false;
for (let i = 0, end = string.length; i < end; i++) {
if (string.charCodeAt(i) > 0x7f) {
isUnicode = true;
break;
}
}
let stringBytes;
if (isUnicode) {
stringBytes = toUTF16BE(string.valueOf());
} else {
stringBytes = fromBinaryString(string.valueOf());
}
if (encryptFn) {
stringBytes = encryptFn(stringBytes);
}
string = toBinaryString(stringBytes);
string = string.replace(escapableRe, c => escapable[c]);
return `(${string})`;
} else if (object instanceof Uint8Array) {
return `<${utils.bytesToHex(object)}>`;
} else if (object instanceof PDFAbstractReference || object instanceof PDFTree || object instanceof SpotColor) {
return object.toString();
} else if (object instanceof Date) {
let string = `D:${pad(object.getUTCFullYear(), 4)}` + pad(object.getUTCMonth() + 1, 2) + pad(object.getUTCDate(), 2) + pad(object.getUTCHours(), 2) + pad(object.getUTCMinutes(), 2) + pad(object.getUTCSeconds(), 2) + 'Z';
if (encryptFn) {
string = toBinaryString(encryptFn(fromBinaryString(string)));
string = string.replace(escapableRe, c => escapable[c]);
}
return `(${string})`;
} else if (Array.isArray(object)) {
const items = [];
for (let i = 0; i < object.length; i++) {
const e = object[i];
items.push(PDFObject.convert(e === undefined ? null : e, encryptFn));
}
return `[${items.join(' ')}]`;
} else if ({}.toString.call(object) === '[object Object]') {
const out = ['<<'];
for (let key in object) {
const val = object[key];
if (val === undefined) continue;
out.push(`/${key} ${PDFObject.convert(val, encryptFn)}`);
}
out.push('>>');
return out.join('\n');
} else if (typeof object === 'number') {
return PDFObject.number(object);
} else {
return `${object}`;
}
}
static number(n) {
if (n > -1e21 && n < 1e21) {
return Math.round(n * 1e6) / 1e6;
}
throw new Error(`unsupported number: ${n}`);
}
}
var zlib = {
deflateSync: data => fflate.zlibSync(data)
};
class PDFReference extends PDFAbstractReference {
constructor(document, id, data = {}) {
super();
this.document = document;
this.id = id;
this.data = data;
this.gen = 0;
this.compress = this.document.compress && !this.data.Filter;
this.uncompressedLength = 0;
this.buffer = [];
}
write(chunk) {
if (!(chunk instanceof Uint8Array)) {
chunk = fromBinaryString(chunk + '\n');
}
this.uncompressedLength += chunk.length;
if (this.data.Length == null) {
this.data.Length = 0;
}
this.buffer.push(chunk);
this.data.Length += chunk.length;
if (this.compress) {
this.data.Filter = 'FlateDecode';
}
}
end(chunk) {
if (chunk) {
this.write(chunk);
}
this.finalize();
}
finalize() {
this.offset = this.document._offset;
const encryptFn = this.document._security ? this.document._security.getEncryptFn(this.id, this.gen) : null;
if (this.buffer.length) {
this.buffer = concat(this.buffer);
if (this.compress) {
this.buffer = zlib.deflateSync(this.buffer);
}
if (encryptFn) {
this.buffer = encryptFn(this.buffer);
}
this.data.Length = this.buffer.length;
}
this.document._write(`${this.id} ${this.gen} obj`);
this.document._write(PDFObject.convert(this.data, encryptFn));
if (this.buffer.length) {
this.document._write('stream');
this.document._write(this.buffer);
this.buffer = [];
this.document._write('\nendstream');
}
this.document._write('endobj');
this.document._refEnd(this);
}
toString() {
return `${this.id} ${this.gen} R`;
}
}
const fArray = new Float32Array(1);
const uArray = new Uint32Array(fArray.buffer);
function PDFNumber(n) {
const rounded = Math.fround(n);
if (rounded <= n) return rounded;
fArray[0] = n;
if (n <= 0) {
uArray[0] += 1;
} else {
uArray[0] -= 1;
}
return fArray[0];
}
function normalizeSides(sides, defaultDefinition = undefined, transformer = v => v) {
if (sides == null || typeof sides === 'object' && Object.keys(sides).length === 0) {
sides = defaultDefinition;
}
if (sides == null || typeof sides !== 'object') {
sides = {
top: sides,
right: sides,
bottom: sides,
left: sides
};
} else if (Array.isArray(sides)) {
if (sides.length === 2) {
sides = {
vertical: sides[0],
horizontal: sides[1]
};
} else {
sides = {
top: sides[0],
right: sides[1],
bottom: sides[2],
left: sides[3]
};
}
}
if ('vertical' in sides || 'horizontal' in sides) {
sides = {
top: sides.vertical,
right: sides.horizontal,
bottom: sides.vertical,
left: sides.horizontal
};
}
return {
top: transformer(sides.top),
right: transformer(sides.right),
bottom: transformer(sides.bottom),
left: transformer(sides.left)
};
}
const MM_TO_CM = 1 / 10;
const CM_TO_IN = 1 / 2.54;
const PX_TO_IN = 1 / 96;
const IN_TO_PT = 72;
const PC_TO_PT = 12;
function cosine(a) {
if (a === 0) return 1;
if (a === 90) return 0;
if (a === 180) return -1;
if (a === 270) return 0;
return Math.cos(a * Math.PI / 180);
}
function sine(a) {
if (a === 0) return 0;
if (a === 90) return 1;
if (a === 180) return 0;
if (a === 270) return -1;
return Math.sin(a * Math.PI / 180);
}
const DEFAULT_MARGINS = {
top: 72,
left: 72,
bottom: 72,
right: 72
};
const SIZES = {
'4A0': [4767.87, 6740.79],
'2A0': [3370.39, 4767.87],
A0: [2383.94, 3370.39],
A1: [1683.78, 2383.94],
A2: [1190.55, 1683.78],
A3: [841.89, 1190.55],
A4: [595.28, 841.89],
A5: [419.53, 595.28],
A6: [297.64, 419.53],
A7: [209.76, 297.64],
A8: [147.4, 209.76],
A9: [104.88, 147.4],
A10: [73.7, 104.88],
B0: [2834.65, 4008.19],
B1: [2004.09, 2834.65],
B2: [1417.32, 2004.09],
B3: [1000.63, 1417.32],
B4: [708.66, 1000.63],
B5: [498.9, 708.66],
B6: [354.33, 498.9],
B7: [249.45, 354.33],
B8: [175.75, 249.45],
B9: [124.72, 175.75],
B10: [87.87, 124.72],
C0: [2599.37, 3676.54],
C1: [1836.85, 2599.37],
C2: [1298.27, 1836.85],
C3: [918.43, 1298.27],
C4: [649.13, 918.43],
C5: [459.21, 649.13],
C6: [323.15, 459.21],
C7: [229.61, 323.15],
C8: [161.57, 229.61],
C9: [113.39, 161.57],
C10: [79.37, 113.39],
RA0: [2437.8, 3458.27],
RA1: [1729.13, 2437.8],
RA2: [1218.9, 1729.13],
RA3: [864.57, 1218.9],
RA4: [609.45, 864.57],
SRA0: [2551.18, 3628.35],
SRA1: [1814.17, 2551.18],
SRA2: [1275.59, 1814.17],
SRA3: [907.09, 1275.59],
SRA4: [637.8, 907.09],
EXECUTIVE: [521.86, 756.0],
FOLIO: [612.0, 936.0],
LEGAL: [612.0, 1008.0],
LETTER: [612.0, 792.0],
TABLOID: [792.0, 1224.0]
};
class PDFPage {
constructor(document, options) {
this.document = document;
this._options = options;
this.size = options.size || 'letter';
this.layout = options.layout || 'portrait';
this.userUnit = options.userUnit || 1.0;
const dimensions = Array.isArray(this.size) ? this.size : SIZES[this.size.toUpperCase()];
this.width = dimensions[this.layout === 'portrait' ? 0 : 1];
this.height = dimensions[this.layout === 'portrait' ? 1 : 0];
this.content = this.document.ref();
this.margins = normalizeSides(options.margin ?? options.margins, DEFAULT_MARGINS, x => document.sizeToPoint(x, 0, this));
this.resources = this.document.ref({
ProcSet: ['PDF', 'Text', 'ImageB', 'ImageC', 'ImageI']
});
this.dictionary = this.document.ref({
Type: 'Page',
Parent: this.document._root.data.Pages,
MediaBox: [0, 0, this.width, this.height],
Contents: this.content,
Resources: this.resources,
UserUnit: this.userUnit
});
this.markings = [];
}
get fonts() {
const data = this.resources.data;
return data.Font != null ? data.Font : data.Font = {};
}
get xobjects() {
const data = this.resources.data;
return data.XObject != null ? data.XObject : data.XObject = {};
}
get ext_gstates() {
const data = this.resources.data;
return data.ExtGState != null ? data.ExtGState : data.ExtGState = {};
}
get patterns() {
const data = this.resources.data;
return data.Pattern != null ? data.Pattern : data.Pattern = {};
}
get colorSpaces() {
const data = this.resources.data;
return data.ColorSpace || (data.ColorSpace = {});
}
get annotations() {
const data = this.dictionary.data;
return data.Annots != null ? data.Annots : data.Annots = [];
}
get structParentTreeKey() {
const data = this.dictionary.data;
return data.StructParents != null ? data.StructParents : data.StructParents = this.document.createStructParentTreeNextKey();
}
get contentWidth() {
return this.width - this.margins.left - this.margins.right;
}
get contentHeight() {
return this.height - this.margins.top - this.margins.bottom;
}
maxY() {
return this.height - this.margins.bottom;
}
write(chunk) {
return this.content.write(chunk);
}
_setTabOrder() {
if (!this.dictionary.Tabs && this.document.hasMarkInfoDictionary()) {
this.dictionary.data.Tabs = 'S';
}
}
end() {
this._setTabOrder();
this.dictionary.end();
this.resources.data.ColorSpace = this.resources.data.ColorSpace || {};
for (let color of Object.values(this.document.spotColors)) {
this.resources.data.ColorSpace[color.id] = color;
}
this.resources.end();
return this.content.end();
}
}
class PDFNameTree extends PDFTree {
_compareKeys(a, b) {
return a.localeCompare(b);
}
_keysName() {
return 'Names';
}
_dataForKey(k) {
return new String(k);
}
}
function isBytes(a) {
return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array';
}
function abytes(b, ...lengths) {
if (!isBytes(b)) throw new Error('Uint8Array expected');
if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
}
function aexists(instance, checkFinished = true) {
if (instance.destroyed) throw new Error('Hash instance has been destroyed');
if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');
}
function aoutput(out, instance) {
abytes(out);
const min = instance.outputLen;
if (out.length < min) {
throw new Error('digestInto() expects output buffer of length at least ' + min);
}
}
function clean(...arrays) {
for (let i = 0; i < arrays.length; i++) {
arrays[i].fill(0);
}
}
function createView(arr) {
return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
}
function rotr(word, shift) {
return word << 32 - shift | word >>> shift;
}
function rotl(word, shift) {
return word << shift | word >>> 32 - shift >>> 0;
}
(() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
(() => typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
Array.from({
length: 256
}, (_, i) => i.toString(16).padStart(2, '0'));
function utf8ToBytes(str) {
if (typeof str !== 'string') throw new Error('string expected');
return new Uint8Array(new TextEncoder().encode(str));
}
function toBytes(data) {
if (typeof data === 'string') data = utf8ToBytes(data);
abytes(data);
return data;
}
class Hash {}
function createHasher(hashCons) {
const hashC = msg => hashCons().update(toBytes(msg)).digest();
const tmp = hashCons();
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = () => hashCons();
return hashC;
}
function setBigUint64(view, byteOffset, value, isLE) {
if (typeof view.setBigUint64 === 'function') return view.setBigUint64(byteOffset, value, isLE);
const _32n = BigInt(32);
const _u32_max = BigInt(0xffffffff);
const wh = Number(value >> _32n & _u32_max);
const wl = Number(value & _u32_max);
const h = isLE ? 4 : 0;
const l = isLE ? 0 : 4;
view.setUint32(byteOffset + h, wh, isLE);
view.setUint32(byteOffset + l, wl, isLE);
}
function Chi(a, b, c) {
return a & b ^ ~a & c;
}
function Maj(a, b, c) {
return a & b ^ a & c ^ b & c;
}
class HashMD extends Hash {
constructor(blockLen, outputLen, padOffset, isLE) {
super();
this.finished = false;
this.length = 0;
this.pos = 0;
this.destroyed = false;
this.blockLen = blockLen;
this.outputLen = outputLen;
this.padOffset = padOffset;
this.isLE = isLE;
this.buffer = new Uint8Array(blockLen);
this.view = createView(this.buffer);
}
update(data) {
aexists(this);
data = toBytes(data);
abytes(data);
const {
view,
buffer,
blockLen
} = this;
const len = data.length;
for (let pos = 0; pos < len;) {
const take = Math.min(blockLen - this.pos, len - pos);
if (take === blockLen) {
const dataView = createView(data);
for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
continue;
}
buffer.set(data.subarray(pos, pos + take), this.pos);
this.pos += take;
pos += take;
if (this.pos === blockLen) {
this.process(view, 0);
this.pos = 0;
}
}
this.length += data.length;
this.roundClean();
return this;
}
digestInto(out) {
aexists(this);
aoutput(out, this);
this.finished = true;
const {
buffer,
view,
blockLen,
isLE
} = this;
let {
pos
} = this;
buffer[pos++] = 0b10000000;
clean(this.buffer.subarray(pos));
if (this.padOffset > blockLen - pos) {
this.process(view, 0);
pos = 0;
}
for (let i = pos; i < blockLen; i++) buffer[i] = 0;
setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
this.process(view, 0);
const oview = createView(out);
const len = this.outputLen;
if (len % 4) throw new Error('_sha2: outputLen should be aligned to 32bit');
const outLen = len / 4;
const state = this.get();
if (outLen > state.length) throw new Error('_sha2: outputLen bigger than state');
for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
}
digest() {
const {
buffer,
outputLen
} = this;
this.digestInto(buffer);
const res = buffer.slice(0, outputLen);
this.destroy();
return res;
}
_cloneInto(to) {
to || (to = new this.constructor());
to.set(...this.get());
const {
blockLen,
buffer,
length,
finished,
destroyed,
pos
} = this;
to.destroyed = destroyed;
to.finished = finished;
to.length = length;
to.pos = pos;
if (length % blockLen) to.buffer.set(buffer);
return to;
}
clone() {
return this._cloneInto();
}
}
const SHA256_IV = Uint32Array.from([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
const SHA224_IV = Uint32Array.from([0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]);
const SHA384_IV = Uint32Array.from([0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939, 0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4]);
const SHA512_IV = Uint32Array.from([0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1, 0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179]);
const SHA1_IV = Uint32Array.from([0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]);
const SHA1_W = new Uint32Array(80);
class SHA1 extends HashMD {
constructor() {
super(64, 20, 8, false);
this.A = SHA1_IV[0] | 0;
this.B = SHA1_IV[1] | 0;
this.C = SHA1_IV[2] | 0;
this.D = SHA1_IV[3] | 0;
this.E = SHA1_IV[4] | 0;
}
get() {
const {
A,
B,
C,
D,
E
} = this;
return [A, B, C, D, E];
}
set(A, B, C, D, E) {
this.A = A | 0;
this.B = B | 0;
this.C = C | 0;
this.D = D | 0;
this.E = E | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4) SHA1_W[i] = view.getUint32(offset, false);
for (let i = 16; i < 80; i++) SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);
let {
A,
B,
C,
D,
E
} = this;
for (let i = 0; i < 80; i++) {
let F, K;
if (i < 20) {
F = Chi(B, C, D);
K = 0x5a827999;
} else if (i < 40) {
F = B ^ C ^ D;
K = 0x6ed9eba1;
} else if (i < 60) {
F = Maj(B, C, D);
K = 0x8f1bbcdc;
} else {
F = B ^ C ^ D;
K = 0xca62c1d6;
}
const T = rotl(A, 5) + F + E + K + SHA1_W[i] | 0;
E = D;
D = C;
C = rotl(B, 30);
B = A;
A = T;
}
A = A + this.A | 0;
B = B + this.B | 0;
C = C + this.C | 0;
D = D + this.D | 0;
E = E + this.E | 0;
this.set(A, B, C, D, E);
}
roundClean() {
clean(SHA1_W);
}
destroy() {
this.set(0, 0, 0, 0, 0);
clean(this.buffer);
}
}
createHasher(() => new SHA1());
const p32 = Math.pow(2, 32);
const K = Array.from({
length: 64
}, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));
const MD5_IV = SHA1_IV.slice(0, 4);
const MD5_W = new Uint32Array(16);
class MD5 extends HashMD {
constructor() {
super(64, 16, 8, true);
this.A = MD5_IV[0] | 0;
this.B = MD5_IV[1] | 0;
this.C = MD5_IV[2] | 0;
this.D = MD5_IV[3] | 0;
}
get() {
const {
A,
B,
C,
D
} = this;
return [A, B, C, D];
}
set(A, B, C, D) {
this.A = A | 0;
this.B = B | 0;
this.C = C | 0;
this.D = D | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4) MD5_W[i] = view.getUint32(offset, true);
let {
A,
B,
C,
D
} = this;
for (let i = 0; i < 64; i++) {
let F, g, s;
if (i < 16) {
F = Chi(B, C, D);
g = i;
s = [7, 12, 17, 22];
} else if (i < 32) {
F = Chi(D, B, C);
g = (5 * i + 1) % 16;
s = [5, 9, 14, 20];
} else if (i < 48) {
F = B ^ C ^ D;
g = (3 * i + 5) % 16;
s = [4, 11, 16, 23];
} else {
F = C ^ (B | ~D);
g = 7 * i % 16;
s = [6, 10, 15, 21];
}
F = F + A + K[i] + MD5_W[g];
A = D;
D = C;
C = B;
B = B + rotl(F, s[i % 4]);
}
A = A + this.A | 0;
B = B + this.B | 0;
C = C + this.C | 0;
D = D + this.D | 0;
this.set(A, B, C, D);
}
roundClean() {
clean(MD5_W);
}
destroy() {
this.set(0, 0, 0, 0);
clean(this.buffer);
}
}
const md5 = createHasher(() => new MD5());
const Rho160 = Uint8Array.from([7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8]);
const Id160 = (() => Uint8Array.from(new Array(16).fill(0).map((_, i) => i)))();
const Pi160 = (() => Id160.map(i => (9 * i + 5) % 16))();
const idxLR = (() => {
const L = [Id160];
const R = [Pi160];
const res = [L, R];
for (let i = 0; i < 4; i++) for (let j of res) j.push(j[i].map(k => Rho160[k]));
return res;
})();
const idxL = (() => idxLR[0])();
const idxR = (() => idxLR[1])();
const shifts160 = [[11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8], [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7], [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9], [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6], [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]].map(i => Uint8Array.from(i));
const shiftsL160 = idxL.map((idx, i) => idx.map(j => shifts160[i][j]));
const shiftsR160 = idxR.map((idx, i) => idx.map(j => shifts160[i][j]));
const Kl160 = Uint32Array.from([0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]);
const Kr160 = Uint32Array.from([0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]);
function ripemd_f(group, x, y, z) {
if (group === 0) return x ^ y ^ z;
if (group === 1) return x & y | ~x & z;
if (group === 2) return (x | ~y) ^ z;
if (group === 3) return x & z | y & ~z;
return x ^ (y | ~z);
}
const BUF_160 = new Uint32Array(16);
class RIPEMD160 extends HashMD {
constructor() {
super(64, 20, 8, true);
this.h0 = 0x67452301 | 0;
this.h1 = 0xefcdab89 | 0;
this.h2 = 0x98badcfe | 0;
this.h3 = 0x10325476 | 0;
this.h4 = 0xc3d2e1f0 | 0;
}
get() {
const {
h0,
h1,
h2,
h3,
h4
} = this;
return [h0, h1, h2, h3, h4];
}
set(h0, h1, h2, h3, h4) {
this.h0 = h0 | 0;
this.h1 = h1 | 0;
this.h2 = h2 | 0;
this.h3 = h3 | 0;
this.h4 = h4 | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4) BUF_160[i] = view.getUint32(offset, true);
let al = this.h0 | 0,
ar = al,
bl = this.h1 | 0,
br = bl,
cl = this.h2 | 0,
cr = cl,
dl = this.h3 | 0,
dr = dl,
el = this.h4 | 0,
er = el;
for (let group = 0; group < 5; group++) {
const rGroup = 4 - group;
const hbl = Kl160[group],
hbr = Kr160[group];
const rl = idxL[group],
rr = idxR[group];
const sl = shiftsL160[group],
sr = shiftsR160[group];
for (let i = 0; i < 16; i++) {
const tl = rotl(al + ripemd_f(group, bl, cl, dl) + BUF_160[rl[i]] + hbl, sl[i]) + el | 0;
al = el, el = dl, dl = rotl(cl, 10) | 0, cl = bl, bl = tl;
}
for (let i = 0; i < 16; i++) {
const tr = rotl(ar + ripemd_f(rGroup, br, cr, dr) + BUF_160[rr[i]] + hbr, sr[i]) + er | 0;
ar = er, er = dr, dr = rotl(cr, 10) | 0, cr = br, br = tr;
}
}
this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
}
roundClean() {
clean(BUF_160);
}
destroy() {
this.destroyed = true;
clean(this.buffer);
this.set(0, 0, 0, 0, 0);
}
}
createHasher(() => new RIPEMD160());
function md5Hash(data) {
return md5.create().update(data).digest();
}
function md5Hex(data) {
return utils.bytesToHex(md5Hash(data));
}
const U32_MASK64 = BigInt(2 ** 32 - 1);
const _32n = BigInt(32);
function fromBig(n, le = false) {
if (le) return {
h: Number(n & U32_MASK64),
l: Number(n >> _32n & U32_MASK64)
};
return {
h: Number(n >> _32n & U32_MASK64) | 0,
l: Number(n & U32_MASK64) | 0
};
}
function split(lst, le = false) {
const len = lst.length;
let Ah = new Uint32Array(len);
let Al = new Uint32Array(len);
for (let i = 0; i < len; i++) {
const {
h,
l
} = fromBig(lst[i], le);
[Ah[i], Al[i]] = [h, l];
}
return [Ah, Al];
}
const shrSH = (h, _l, s) => h >>> s;
const shrSL = (h, l, s) => h << 32 - s | l >>> s;
const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
function add(Ah, Al, Bh, Bl) {
const l = (Al >>> 0) + (Bl >>> 0);
return {
h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
l: l | 0
};
}
const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
const SHA256_K = Uint32Array.from([0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2]);
const SHA256_W = new Uint32Array(64);
class SHA256 extends HashMD {
constructor(outputLen = 32) {
super(64, outputLen, 8, false);
this.A = SHA256_IV[0] | 0;
this.B = SHA256_IV[1] | 0;
this.C = SHA256_IV[2] | 0;
this.D = SHA256_IV[3] | 0;
this.E = SHA256_IV[4] | 0;
this.F = SHA256_IV[5] | 0;
this.G = SHA256_IV[6] | 0;
this.H = SHA256_IV[7] | 0;
}
get() {
const {
A,
B,
C,
D,
E,
F,
G,
H
} = this;
return [A, B, C, D, E, F, G, H];
}
set(A, B, C, D, E, F, G, H) {
this.A = A | 0;
this.B = B | 0;
this.C = C | 0;
this.D = D | 0;
this.E = E | 0;
this.F = F | 0;
this.G = G | 0;
this.H = H | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
for (let i = 16; i < 64; i++) {
const W15 = SHA256_W[i - 15];
const W2 = SHA256_W[i - 2];
const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
}
let {
A,
B,
C,
D,
E,
F,
G,
H
} = this;
for (let i = 0; i < 64; i++) {
const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
const T2 = sigma0 + Maj(A, B, C) | 0;
H = G;
G = F;
F = E;
E = D + T1 | 0;
D = C;
C = B;
B = A;
A = T1 + T2 | 0;
}
A = A + this.A | 0;
B = B + this.B | 0;
C = C + this.C | 0;
D = D + this.D | 0;
E = E + this.E | 0;
F = F + this.F | 0;
G = G + this.G | 0;
H = H + this.H | 0;
this.set(A, B, C, D, E, F, G, H);
}
roundClean() {
clean(SHA256_W);
}
destroy() {
this.set(0, 0, 0, 0, 0, 0, 0, 0);
clean(this.buffer);
}
}
class SHA224 extends SHA256 {
constructor() {
super(28);
this.A = SHA224_IV[0] | 0;
this.B = SHA224_IV[1] | 0;
this.C = SHA224_IV[2] | 0;
this.D = SHA224_IV[3] | 0;
this.E = SHA224_IV[4] | 0;
this.F = SHA224_IV[5] | 0;
this.G = SHA224_IV[6] | 0;
this.H = SHA224_IV[7] | 0;
}
}
const K512 = (() => split(['0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc', '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118', '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2', '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694', '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65', '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5', '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4', '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70', '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df', '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b', '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30', '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8', '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8', '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3', '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec', '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b', '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178', '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b', '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c', '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'].map(n => BigInt(n))))();
const SHA512_Kh = (() => K512[0])();
const SHA512_Kl = (() => K512[1])();
const SHA512_W_H = new Uint32Array(80);
const SHA512_W_L = new Uint32Array(80);
class SHA512 extends HashMD {
constructor(outputLen = 64) {
super(128, outputLen, 16, false);
this.Ah = SHA512_IV[0] | 0;
this.Al = SHA512_IV[1] | 0;
this.Bh = SHA512_IV[2] | 0;
this.Bl = SHA512_IV[3] | 0;
this.Ch = SHA512_IV[4] | 0;
this.Cl = SHA512_IV[5] | 0;
this.Dh = SHA512_IV[6] | 0;
this.Dl = SHA512_IV[7] | 0;
this.Eh = SHA512_IV[8] | 0;
this.El = SHA512_IV[9] | 0;
this.Fh = SHA512_IV[10] | 0;
this.Fl = SHA512_IV[11] | 0;
this.Gh = SHA512_IV[12] | 0;
this.Gl = SHA512_IV[13] | 0;
this.Hh = SHA512_IV[14] | 0;
this.Hl = SHA512_IV[15] | 0;
}
get() {
const {
Ah,
Al,
Bh,
Bl,
Ch,
Cl,
Dh,
Dl,
Eh,
El,
Fh,
Fl,
Gh,
Gl,
Hh,
Hl
} = this;
return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
}
set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
this.Ah = Ah | 0;
this.Al = Al | 0;
this.Bh = Bh | 0;
this.Bl = Bl | 0;
this.Ch = Ch | 0;
this.Cl = Cl | 0;
this.Dh = Dh | 0;
this.Dl = Dl | 0;
this.Eh = Eh | 0;
this.El = El | 0;
this.Fh = Fh | 0;
this.Fl = Fl | 0;
this.Gh = Gh | 0;
this.Gl = Gl | 0;
this.Hh = Hh | 0;
this.Hl = Hl | 0;
}
process(view, offset) {
for (let i = 0; i < 16; i++, offset += 4) {
SHA512_W_H[i] = view.getUint32(offset);
SHA512_W_L[i] = view.getUint32(offset += 4);
}
for (let i = 16; i < 80; i++) {
const W15h = SHA512_W_H[i - 15] | 0;
const W15l = SHA512_W_L[i - 15] | 0;
const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
const W2h = SHA512_W_H[i - 2] | 0;
const W2l = SHA512_W_L[i - 2] | 0;
const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
SHA512_W_H[i] = SUMh | 0;
SHA512_W_L[i] = SUMl | 0;
}
let {
Ah,
Al,
Bh,
Bl,
Ch,
Cl,
Dh,
Dl,
Eh,
El,
Fh,
Fl,
Gh,
Gl,
Hh,
Hl
} = this;
for (let i = 0; i < 80; i++) {
const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
const CHIh = Eh & Fh ^ ~Eh & Gh;
const CHIl = El & Fl ^ ~El & Gl;
const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
const T1l = T1ll | 0;
const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
Hh = Gh | 0;
Hl = Gl | 0;
Gh = Fh | 0;
Gl = Fl | 0;
Fh = Eh | 0;
Fl = El | 0;
({
h: Eh,
l: El
} = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
Dh = Ch | 0;
Dl = Cl | 0;
Ch = Bh | 0;
Cl = Bl | 0;
Bh = Ah | 0;
Bl = Al | 0;
const All = add3L(T1l, sigma0l, MAJl);
Ah = add3H(All, T1h, sigma0h, MAJh);
Al = All | 0;
}
({
h: Ah,
l: Al
} = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
({
h: Bh,
l: Bl
} = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
({
h: Ch,
l: Cl
} = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
({
h: Dh,
l: Dl
} = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
({
h: Eh,
l: El
} = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
({
h: Fh,
l: Fl
} = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
({
h: Gh,
l: Gl
} = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
({
h: Hh,
l: Hl
} = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
}
roundClean() {
clean(SHA512_W_H, SHA512_W_L);
}
destroy() {
clean(this.buffer);
this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
}
}
class SHA384 extends SHA512 {
constructor() {
super(48);
this.Ah = SHA384_IV[0] | 0;
this.Al = SHA384_IV[1] | 0;
this.Bh = SHA384_IV[2] | 0;
this.Bl = SHA384_IV[3] | 0;
this.Ch = SHA384_IV[4] | 0;
this.Cl = SHA384_IV[5] | 0;
this.Dh = SHA384_IV[6] | 0;
this.Dl = SHA384_IV[7] | 0;
this.Eh = SHA384_IV[8] | 0;
this.El = SHA384_IV[9] | 0;
this.Fh = SHA384_IV[10] | 0;
this.Fl = SHA384_IV[11] | 0;
this.Gh = SHA384_IV[12] | 0;
this.Gl = SHA384_IV[13] | 0;
this.Hh = SHA384_IV[14] | 0;
this.Hl = SHA384_IV[15] | 0;
}
}
const T224_IV = Uint32Array.from([0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf, 0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1]);
const T256_IV = Uint32Array.from([0x22312194, 0xfc2bf72c, 0x9f555fa3, 0xc84c64c2, 0x2393b86b, 0x6f53b151, 0x96387719, 0x5940eabd, 0x96283ee2, 0xa88effe3, 0xbe5e1e25, 0x53863992, 0x2b0199fc, 0x2c85b8aa, 0x0eb72ddc, 0x81c52ca2]);
class SHA512_224 extends SHA512 {
constructor() {
super(28);
this.Ah = T224_IV[0] | 0;
this.Al = T224_IV[1] | 0;
this.Bh = T224_IV[2] | 0;
this.Bl = T224_IV[3] | 0;
this.Ch = T224_IV[4] | 0;
this.Cl = T224_IV[5] | 0;
this.Dh = T224_IV[6] | 0;
this.Dl = T224_IV[7] | 0;
this.Eh = T224_IV[8] | 0;
this.El = T224_IV[9] | 0;
this.Fh = T224_IV[10] | 0;
this.Fl = T224_IV[11] | 0;
this.Gh = T224_IV[12] | 0;
this.Gl = T224_IV[13] | 0;
this.Hh = T224_IV[14] | 0;
this.Hl = T224_IV[15] | 0;
}
}
class SHA512_256 extends SHA512 {
constructor() {
super(32);
this.Ah = T256_IV[0] | 0;
this.Al = T256_IV[1] | 0;
this.Bh = T256_IV[2] | 0;
this.Bl = T256_IV[3] | 0;
this.Ch = T256_IV[4] | 0;
this.Cl = T256_IV[5] | 0;
this.Dh = T256_IV[6] | 0;
this.Dl = T256_IV[7] | 0;
this.Eh = T256_IV[8] | 0;
this.El = T256_IV[9] | 0;
this.Fh = T256_IV[10] | 0;
this.Fl = T256_IV[11] | 0;
this.Gh = T256_IV[12] | 0;
this.Gl = T256_IV[13] | 0;
this.Hh = T256_IV[14] | 0;
this.Hl = T256_IV[15] | 0;
}
}
const sha256 = createHasher(() => new SHA256());
createHasher(() => new SHA224());
createHasher(() => new SHA512());
createHasher(() => new SHA384());
createHasher(() => new SHA512_256());
createHasher(() => new SHA512_224());
function sha256Hash(data) {
return sha256(data);
}
function aesCbcEncrypt(data, key, iv, padding = true) {
return aes.cbc(key, iv, {
disablePadding: !padding
}).encrypt(data);
}
function aesEcbEncrypt(data, key) {
return aes.ecb(key, {
disablePadding: true
}).encrypt(data);
}
function rc4(data, key) {
const s = new Uint8Array(256);
for (let i = 0; i < 256; i++) {
s[i] = i;
}
let j = 0;
for (let i = 0; i < 256; i++) {
j = j + s[i] + key[i % key.length] & 0xff;
[s[i], s[j]] = [s[j], s[i]];
}
const output = new Uint8Array(data.length);
for (let i = 0, j = 0, k = 0; k < data.length; k++) {
i = i + 1 & 0xff;
j = j + s[i] & 0xff;
[s[i], s[j]] = [s[j], s[i]];
output[k] = data[k] ^ s[s[i] + s[j] & 0xff];
}
return output;
}
function randomBytes(length) {
const bytes = new Uint8Array(length);
globalThis.crypto.getRandomValues(bytes);
return bytes;
}
function inRange(value, rangeGroup) {
if (value < rangeGroup[0]) return false;
let startRange = 0;
let endRange = rangeGroup.length / 2;
while (startRange <= endRange) {
const middleRange = Math.floor((startRange + endRange) / 2);
const arrayIndex = middleRange * 2;
if (value >= rangeGroup[arrayIndex] && value <= rangeGroup[arrayIndex + 1]) {
return true;
}
if (value > rangeGroup[arrayIndex + 1]) {
startRange = middleRange + 1;
} else {
endRange = middleRange - 1;
}
}
return false;
}
const unassigned_code_points = [0x0221, 0x0221, 0x0234, 0x024f, 0x02ae, 0x02af, 0x02ef, 0x02ff, 0x0350, 0x035f, 0x0370, 0x0373, 0x0376, 0x0379, 0x037b, 0x037d, 0x037f, 0x0383, 0x038b, 0x038b, 0x038d, 0x038d, 0x03a2, 0x03a2, 0x03cf, 0x03cf, 0x03f7, 0x03ff, 0x0487, 0x0487, 0x04cf, 0x04cf, 0x04f6, 0x04f7, 0x04fa, 0x04ff, 0x0510, 0x0530, 0x0557, 0x0558, 0x0560, 0x0560, 0x0588, 0x0588, 0x058b, 0x0590, 0x05a2, 0x05a2, 0x05ba, 0x05ba, 0x05c5, 0x05cf, 0x05eb, 0x05ef, 0x05f5, 0x060b, 0x060d, 0x061a, 0x061c, 0x061e, 0x0620, 0x0620, 0x063b, 0x063f, 0x0656, 0x065f, 0x06ee, 0x06ef, 0x06ff, 0x06ff, 0x070e, 0x070e, 0x072d, 0x072f, 0x074b, 0x077f, 0x07b2, 0x0900, 0x0904, 0x0904, 0x093a, 0x093b, 0x094e, 0x094f, 0x0955, 0x0957, 0x0971, 0x0980, 0x0984, 0x0984, 0x098d, 0x098e, 0x0991, 0x0992, 0x09a9, 0x09a9, 0x09b1, 0x09b1, 0x09b3, 0x09b5, 0x09ba, 0x09bb, 0x09bd, 0x09bd, 0x09c5, 0x09c6, 0x09c9, 0x09ca, 0x09ce, 0x09d6, 0x09d8, 0x09db, 0x09de, 0x09de, 0x09e4, 0x09e5, 0x09fb, 0x0a01, 0x0a03, 0x0a04, 0x0a0b, 0x0a0e, 0x0a11, 0x0a12, 0x0a29, 0x0a29, 0x0a31, 0x0a31, 0x0a34, 0x0a34, 0x0a37, 0x0a37, 0x0a3a, 0x0a3b, 0x0a3d, 0x0a3d, 0x0a43, 0x0a46, 0x0a49, 0x0a4a, 0x0a4e, 0x0a58, 0x0a5d, 0x0a5d, 0x0a5f, 0x0a65, 0x0a75, 0x0a80, 0x0a84, 0x0a84, 0x0a8c, 0x0a8c, 0x0a8e, 0x0a8e, 0x0a92, 0x0a92, 0x0aa9, 0x0aa9, 0x0ab1, 0x0ab1, 0x0ab4, 0x0ab4, 0x0aba, 0x0abb, 0x0ac6, 0x0ac6, 0x0aca, 0x0aca, 0x0ace, 0x0acf, 0x0ad1, 0x0adf, 0x0ae1, 0x0ae5, 0x0af0, 0x0b00, 0x0b04, 0x0b04, 0x0b0d, 0x0b0e, 0x0b11, 0x0b12, 0x0b29, 0x0b29, 0x0b31, 0x0b31, 0x0b34, 0x0b35, 0x0b3a, 0x0b3b, 0x0b44, 0x0b46, 0x0b49, 0x0b4a, 0x0b4e, 0x0b55, 0x0b58, 0x0b5b, 0x0b5e, 0x0b5e, 0x0b62, 0x0b65, 0x0b71, 0x0b81, 0x0b84, 0x0b84, 0x0b8b, 0x0b8d, 0x0b91, 0x0b91, 0x0b96, 0x0b98, 0x0b9b, 0x0b9b, 0x0b9d, 0x0b9d, 0x0ba0, 0x0ba2, 0x0ba5, 0x0ba7, 0x0bab, 0x0bad, 0x0bb6, 0x0bb6, 0x0bba, 0x0bbd, 0x0bc3, 0x0bc5, 0x0bc9, 0x0bc9, 0x0bce, 0x0bd6, 0x0bd8, 0x0be6, 0x0bf3, 0x0c00, 0x0c04, 0x0c04, 0x0c0d, 0x0c0d, 0x0c11, 0x0c11, 0x0c29, 0x0c29, 0x0c34, 0x0c34, 0x0c3a, 0x0c3d, 0x0c45, 0x0c45, 0x0c49, 0x0c49, 0x0c4e, 0x0c54, 0x0c57, 0x0c5f, 0x0c62, 0x0c65, 0x0c70, 0x0c81, 0x0c84, 0x0c84, 0x0c8d, 0x0c8d, 0x0c91, 0x0c91, 0x0ca9, 0x0ca9, 0x0cb4, 0x0cb4, 0x0cba, 0x0cbd, 0x0cc5, 0x0cc5, 0x0cc9, 0x0cc9, 0x0cce, 0x0cd4, 0x0cd7, 0x0cdd, 0x0cdf, 0x0cdf, 0x0ce2, 0x0ce5, 0x0cf0, 0x0d01, 0x0d04, 0x0d04, 0x0d0d, 0x0d0d, 0x0d11, 0x0d11, 0x0d29, 0x0d29, 0x0d3a, 0x0d3d, 0x0d44, 0x0d45, 0x0d49, 0x0d49, 0x0d4e, 0x0d56, 0x0d58, 0x0d5f, 0x0d62, 0x0d65, 0x0d70, 0x0d81, 0x0d84, 0x0d84, 0x0d97, 0x0d99, 0x0db2, 0x0db2, 0x0dbc, 0x0dbc, 0x0dbe, 0x0dbf, 0x0dc7, 0x0dc9, 0x0dcb, 0x0dce, 0x0dd5, 0x0dd5, 0x0dd7, 0x0dd7, 0x0de0, 0x0df1, 0x0df5, 0x0e00, 0x0e3b, 0x0e3e, 0x0e5c, 0x0e80, 0x0e83, 0x0e83, 0x0e85, 0x0e86, 0x0e89, 0x0e89, 0x0e8b, 0x0e8c, 0x0e8e, 0x0e93, 0x0e98, 0x0e98, 0x0ea0, 0x0ea0, 0x0ea4, 0x0ea4, 0x0ea6, 0x0ea6, 0x0ea8, 0x0ea9, 0x0eac, 0x0eac, 0x0eba, 0x0eba, 0x0ebe, 0x0ebf, 0x0ec5, 0x0ec5, 0x0ec7, 0x0ec7, 0x0ece, 0x0ecf, 0x0eda, 0x0edb, 0x0ede, 0x0eff, 0x0f48, 0x0f48, 0x0f6b, 0x0f70, 0x0f8c, 0x0f8f, 0x0f98, 0x0f98, 0x0fbd, 0x0fbd, 0x0fcd, 0x0fce, 0x0fd0, 0x0fff, 0x1022, 0x1022, 0x1028, 0x1028, 0x102b, 0x102b, 0x1033, 0x1035, 0x103a, 0x103f, 0x105a, 0x109f, 0x10c6, 0x10cf, 0x10f9, 0x10fa, 0x10fc, 0x10ff, 0x115a, 0x115e, 0x11a3, 0x11a7, 0x11fa, 0x11ff, 0x1207, 0x1207, 0x1247, 0x1247, 0x1249, 0x1249, 0x124e, 0x124f, 0x1257, 0x1257, 0x1259, 0x1259, 0x125e, 0x125f, 0x1287, 0x1287, 0x1289, 0x1289, 0x128e, 0x128f, 0x12af, 0x12af, 0x12b1, 0x12b1, 0x12b6, 0x12b7, 0x12bf, 0x12bf, 0x12c1, 0x12c1, 0x12c6, 0x12c7, 0x12cf, 0x12cf, 0x12d7, 0x12d7, 0x12ef, 0x12ef, 0x130f, 0x130f, 0x1311, 0x1311, 0x1316, 0x1317, 0x131f, 0x131f, 0x1347, 0x1347, 0x135b, 0x1360, 0x137d, 0x139f, 0x13f5, 0x1400, 0x1677, 0x167f, 0x169d, 0x169f, 0x16f1, 0x16ff, 0x170d, 0x170d, 0x1715, 0x171f, 0x1737, 0x173f, 0x1754, 0x175f, 0x176d, 0x176d, 0x1771, 0x1771, 0x1774, 0x177f, 0x17dd, 0x17df, 0x17ea, 0x17ff, 0x180f, 0x180f, 0x181a, 0x181f, 0x1878, 0x187f, 0x18aa, 0x1dff, 0x1e9c, 0x1e9f, 0x1efa, 0x1eff, 0x1f16, 0x1f17, 0x1f1e, 0x1f1f, 0x1f46, 0x1f47, 0x1f4e, 0x1f4f, 0x1f58, 0x1f58, 0x1f5a, 0x1f5a, 0x1f5c, 0x1f5c, 0x1f5e, 0x1f5e, 0x1f7e, 0x1f7f, 0x1fb5, 0x1fb5, 0x1fc5, 0x1fc5, 0x1fd4, 0x1fd5, 0x1fdc, 0x1fdc, 0x1ff0, 0x1ff1, 0x1ff5, 0x1ff5, 0x1fff, 0x1fff, 0x2053, 0x2056, 0x2058, 0x205e, 0x2064, 0x2069, 0x2072, 0x2073, 0x208f, 0x209f, 0x20b2, 0x20cf, 0x20eb, 0x20ff, 0x213b, 0x213c, 0x214c, 0x2152, 0x2184, 0x218f, 0x23cf, 0x23ff, 0x2427, 0x243f, 0x244b, 0x245f, 0x24ff, 0x24ff, 0x2614, 0x2615, 0x2618, 0x2618, 0x267e, 0x267f, 0x268a, 0x2700, 0x2705, 0x2705, 0x270a, 0x270b, 0x2728, 0x2728, 0x274c, 0x274c, 0x274e, 0x274e, 0x2753, 0x2755, 0x2757, 0x2757, 0x275f, 0x2760, 0x2795, 0x2797, 0x27b0, 0x27b0, 0x27bf, 0x27cf, 0x27ec, 0x27ef, 0x2b00, 0x2e7f, 0x2e9a, 0x2e9a, 0x2ef4, 0x2eff, 0x2fd6, 0x2fef, 0x2ffc, 0x2fff, 0x3040, 0x3040, 0x3097, 0x3098, 0x3100, 0x3104, 0x312d, 0x3130, 0x318f, 0x318f, 0x31b8, 0x31ef, 0x321d, 0x321f, 0x3244, 0x3250, 0x327c, 0x327e, 0x32cc, 0x32cf, 0x32ff, 0x32ff, 0x3377, 0x337a, 0x33de, 0x33df, 0x33ff, 0x33ff, 0x4db6, 0x4dff, 0x9fa6, 0x9fff, 0xa48d, 0xa48f, 0xa4c7, 0xabff, 0xd7a4, 0xd7ff, 0xfa2e, 0xfa2f, 0xfa6b, 0xfaff, 0xfb07, 0xfb12, 0xfb18, 0xfb1c, 0xfb37, 0xfb37, 0xfb3d, 0xfb3d, 0xfb3f, 0xfb3f, 0xfb42, 0xfb42, 0xfb45, 0xfb45, 0xfbb2, 0xfbd2, 0xfd40, 0xfd4f, 0xfd90, 0xfd91, 0xfdc8, 0xfdcf, 0xfdfd, 0xfdff, 0xfe10, 0xfe1f, 0xfe24, 0xfe2f, 0xfe47, 0xfe48, 0xfe53, 0xfe53, 0xfe67, 0xfe67, 0xfe6c, 0xfe6f, 0xfe75, 0xfe75, 0xfefd, 0xfefe, 0xff00, 0xff00, 0xffbf, 0xffc1, 0xffc8, 0xffc9, 0xffd0, 0xffd1, 0xffd8, 0xffd9, 0xffdd, 0xffdf, 0xffe7, 0xffe7, 0xffef, 0xfff8, 0x10000, 0x102ff, 0x1031f, 0x1031f, 0x10324, 0x1032f, 0x1034b, 0x103ff, 0x10426, 0x10427, 0x1044e, 0x1cfff, 0x1d0f6, 0x1d0ff, 0x1d127, 0x1d129, 0x1d1de, 0x1d3ff, 0x1d455, 0x1d455, 0x1d49d, 0x1d49d, 0x1d4a0, 0x1d4a1, 0x1d4a3, 0x1d4a4, 0x1d4a7, 0x1d4a8, 0x1d4ad, 0x1d4ad, 0x1d4ba, 0x1d4ba, 0x1d4bc, 0x1d4bc, 0x1d4c1, 0x1d4c1, 0x1d4c4, 0x1d4c4, 0x1d506, 0x1d506, 0x1d50b, 0x1d50c, 0x1d515, 0x1d515, 0x1d51d, 0x1d51d, 0x1d53a, 0x1d53a, 0x1d53f, 0x1d53f, 0x1d545, 0x1d545, 0x1d547, 0x1d549, 0x1d551, 0x1d551, 0x1d6a4, 0x1d6a7, 0x1d7ca, 0x1d7cd, 0x1d800, 0x1fffd, 0x2a6d7, 0x2f7ff, 0x2fa1e, 0x2fffd, 0x30000, 0x3fffd, 0x40000, 0x4fffd, 0x50000, 0x5fffd, 0x60000, 0x6fffd, 0x70000, 0x7fffd, 0x80000, 0x8fffd, 0x90000, 0x9fffd, 0xa0000, 0xafffd, 0xb0000, 0xbfffd, 0xc0000, 0xcfffd, 0xd0000, 0xdfffd, 0xe0000, 0xe0000, 0xe0002, 0xe001f, 0xe0080, 0xefffd];
const isUnassignedCodePoint = character => inRange(character, unassigned_code_points);
const commonly_mapped_to_nothing = [0x00ad, 0x00ad, 0x034f, 0x034f, 0x1806, 0x1806, 0x180b, 0x180b, 0x180c, 0x180c, 0x180d, 0x180d, 0x200b, 0x200b, 0x200c, 0x200c, 0x200d, 0x200d, 0x2060, 0x2060, 0xfe00, 0xfe00, 0xfe01, 0xfe01, 0xfe02, 0xfe02, 0xfe03, 0xfe03, 0xfe04, 0xfe04, 0xfe05, 0xfe05, 0xfe06, 0xfe06, 0xfe07, 0xfe07, 0xfe08, 0xfe08, 0xfe09, 0xfe09, 0xfe0a, 0xfe0a, 0xfe0b, 0xfe0b, 0xfe0c, 0xfe0c, 0xfe0d, 0xfe0d, 0xfe0e, 0xfe0e, 0xfe0f, 0xfe0f, 0xfeff, 0xfeff];
const isCommonlyMappedToNothing = character => inRange(character, commonly_mapped_to_nothing);
const non_ASCII_space_characters = [0x00a0, 0x00a0, 0x1680, 0x1680, 0x2000, 0x2000, 0x2001, 0x2001, 0x2002, 0x2002, 0x2003, 0x2003, 0x2004, 0x2004, 0x2005, 0x2005, 0x2006, 0x2006, 0x2007, 0x2007, 0x2008, 0x2008, 0x2009, 0x2009, 0x200a, 0x200a, 0x200b, 0x200b, 0x202f, 0x202f, 0x205f, 0x205f, 0x3000, 0x3000];
const isNonASCIISpaceCharacter = character => inRange(character, non_ASCII_space_characters);
const non_ASCII_controls_characters = [0x0080, 0x009f, 0x06dd, 0x06dd, 0x070f, 0x070f, 0x180e, 0x180e, 0x200c, 0x200c, 0x200d, 0x200d, 0x2028, 0x2028, 0x2029, 0x2029, 0x2060, 0x2060, 0x2061, 0x2061, 0x2062, 0x2062, 0x2063, 0x2063, 0x206a, 0x206f, 0xfeff, 0xfeff, 0xfff9, 0xfffc, 0x1d173, 0x1d17a];
const non_character_codepoints = [0xfdd0, 0xfdef, 0xfffe, 0xffff, 0x1fffe, 0x1ffff, 0x2fffe, 0x2ffff, 0x3fffe, 0x3ffff, 0x4fffe, 0x4ffff, 0x5fffe, 0x5ffff, 0x6fffe, 0x6ffff, 0x7fffe, 0x7ffff, 0x8fffe, 0x8ffff, 0x9fffe, 0x9ffff, 0xafffe, 0xaffff, 0xbfffe, 0xbffff, 0xcfffe, 0xcffff, 0xdfffe, 0xdffff, 0xefffe, 0xeffff, 0x10fffe, 0x10ffff];
const prohibited_characters = [0, 0x001f, 0x007f, 0x007f, 0x0340, 0x0340, 0x0341, 0x0341, 0x200e, 0x200e, 0x200f, 0x200f, 0x202a, 0x202a, 0x202b, 0x202b, 0x202c, 0x202c, 0x202d, 0x202d, 0x202e, 0x202e, 0x206a, 0x206a, 0x206b, 0x206b, 0x206c, 0x206c, 0x206d, 0x206d, 0x206e, 0x206e, 0x206f, 0x206f, 0x2ff0, 0x2ffb, 0xd800, 0xdfff, 0xe000, 0xf8ff, 0xfff9, 0xfff9, 0xfffa, 0xfffa, 0xfffb, 0xfffb, 0xfffc, 0xfffc, 0xfffd, 0xfffd, 0xe0001, 0xe0001, 0xe0020, 0xe007f, 0xf0000, 0xffffd, 0x100000, 0x10fffd];
const isProhibitedCharacter = character => inRange(character, non_ASCII_space_characters) || inRange(character, prohibited_characters) || inRange(character, non_ASCII_controls_characters) || inRange(character, non_character_codepoints);
const bidirectional_r_al = [0x05be, 0x05be, 0x05c0, 0x05c0, 0x05c3, 0x05c3, 0x05d0, 0x05ea, 0x05f0, 0x05f4, 0x061b, 0x061b, 0x061f, 0x061f, 0x0621, 0x063a, 0x0640, 0x064a, 0x066d, 0x066f, 0x0671, 0x06d5, 0x06dd, 0x06dd, 0x06e5, 0x06e6, 0x06fa, 0x06fe, 0x0700, 0x070d, 0x0710, 0x0710, 0x0712, 0x072c, 0x0780, 0x07a5, 0x07b1, 0x07b1, 0x200f, 0x200f, 0xfb1d, 0xfb1d, 0xfb1f, 0xfb28, 0xfb2a, 0xfb36, 0xfb38, 0xfb3c, 0xfb3e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfb46, 0xfbb1, 0xfbd3, 0xfd3d, 0xfd50, 0xfd8f, 0xfd92, 0xfdc7, 0xfdf0, 0xfdfc, 0xfe70, 0xfe74, 0xfe76, 0xfefc];
const isBidirectionalRAL = character => inRange(character, bidirectional_r_al);
const bidirectional_l = [0x0041, 0x005a, 0x0061, 0x007a, 0x00aa, 0x00aa, 0x00b5, 0x00b5, 0x00ba, 0x00ba, 0x00c0, 0x00d6, 0x00d8, 0x00f6, 0x00f8, 0x0220, 0x0222, 0x0233, 0x0250, 0x02ad, 0x02b0, 0x02b8, 0x02bb, 0x02c1, 0x02d0, 0x02d1, 0x02e0, 0x02e4, 0x02ee, 0x02ee, 0x037a, 0x037a, 0x0386, 0x0386, 0x0388, 0x038a, 0x038c, 0x038c, 0x038e, 0x03a1, 0x03a3, 0x03ce, 0x03d0, 0x03f5, 0x0400, 0x0482, 0x048a, 0x04ce, 0x04d0, 0x04f5, 0x04f8, 0x04f9, 0x0500, 0x050f, 0x0531, 0x0556, 0x0559, 0x055f, 0x0561, 0x0587, 0x0589, 0x0589, 0x0903, 0x0903, 0x0905, 0x0939, 0x093d, 0x0940, 0x0949, 0x094c, 0x0950, 0x0950, 0x0958, 0x0961, 0x0964, 0x0970, 0x0982, 0x0983, 0x0985, 0x098c, 0x098f, 0x0990, 0x0993, 0x09a8, 0x09aa, 0x09b0, 0x09b2, 0x09b2, 0x09b6, 0x09b9, 0x09be, 0x09c0, 0x09c7, 0x09c8, 0x09cb, 0x09cc, 0x09d7, 0x09d7, 0x09dc, 0x09dd, 0x09df, 0x09e1, 0x09e6, 0x09f1, 0x09f4, 0x09fa, 0x0a05, 0x0a0a, 0x0a0f, 0x0a10, 0x0a13, 0x0a28, 0x0a2a, 0x0a30, 0x0a32, 0x0a33, 0x0a35, 0x0a36, 0x0a38, 0x0a39, 0x0a3e, 0x0a40, 0x0a59, 0x0a5c, 0x0a5e, 0x0a5e, 0x0a66, 0x0a6f, 0x0a72, 0x0a74, 0x0a83, 0x0a83, 0x0a85, 0x0a8b, 0x0a8d, 0x0a8d, 0x0a8f, 0x0a91, 0x0a93, 0x0aa8, 0x0aaa, 0x0ab0, 0x0ab2, 0x0ab3, 0x0ab5, 0x0ab9, 0x0abd, 0x0ac0, 0x0ac9, 0x0ac9, 0x0acb, 0x0acc, 0x0ad0, 0x0ad0, 0x0ae0, 0x0ae0, 0x0ae6, 0x0aef, 0x0b02, 0x0b03, 0x0b05, 0x0b0c, 0x0b0f, 0x0b10, 0x0b13, 0x0b28, 0x0b2a, 0x0b30, 0x0b32, 0x0b33, 0x0b36, 0x0b39, 0x0b3d, 0x0b3e, 0x0b40, 0x0b40, 0x0b47, 0x0b48, 0x0b4b, 0x0b4c, 0x0b57, 0x0b57, 0x0b5c, 0x0b5d, 0x0b5f, 0x0b61, 0x0b66, 0x0b70, 0x0b83, 0x0b83, 0x0b85, 0x0b8a, 0x0b8e, 0x0b90, 0x0b92, 0x0b95, 0x0b99, 0x0b9a, 0x0b9c, 0x0b9c, 0x0b9e, 0x0b9f, 0x0ba3, 0x0ba4, 0x0ba8, 0x0baa, 0x0bae, 0x0bb5, 0x0bb7, 0x0bb9, 0x0bbe, 0x0bbf, 0x0bc1, 0x0bc2, 0x0bc6, 0x0bc8, 0x0bca, 0x0bcc, 0x0bd7, 0x0bd7, 0x0be7, 0x0bf2, 0x0c01, 0x0c03, 0x0c05, 0x0c0c, 0x0c0e, 0x0c10, 0x0c12, 0x0c28, 0x0c2a, 0x0c33, 0x0c35, 0x0c39, 0x0c41, 0x0c44, 0x0c60, 0x0c61, 0x0c66, 0x0c6f, 0x0c82, 0x0c83, 0x0c85, 0x0c8c, 0x0c8e, 0x0c90, 0x0c92, 0x0ca8, 0x0caa, 0x0cb3, 0x0cb5, 0x0cb9, 0x0cbe, 0x0cbe, 0x0cc0, 0x0cc4, 0x0cc7, 0x0cc8, 0x0cca, 0x0ccb, 0x0cd5, 0x0cd6, 0x0cde, 0x0cde, 0x0ce0, 0x0ce1, 0x0ce6, 0x0cef, 0x0d02, 0x0d03, 0x0d05, 0x0d0c, 0x0d0e, 0x0d10, 0x0d12, 0x0d28, 0x0d2a, 0x0d39, 0x0d3e, 0x0d40, 0x0d46, 0x0d48, 0x0d4a, 0x0d4c, 0x0d57, 0x0d57, 0x0d60, 0x0d61, 0x0d66, 0x0d6f, 0x0d82, 0x0d83, 0x0d85, 0x0d96, 0x0d9a, 0x0db1, 0x0db3, 0x0dbb, 0x0dbd, 0x0dbd, 0x0dc0, 0x0dc6, 0x0dcf, 0x0dd1, 0x0dd8, 0x0ddf, 0x0df2, 0x0df4, 0x0e01, 0x0e30, 0x0e32, 0x0e33, 0x0e40, 0x0e46, 0x0e4f, 0x0e5b, 0x0e81, 0x0e82, 0x0e84, 0x0e84, 0x0e87, 0x0e88, 0x0e8a, 0x0e8a, 0x0e8d, 0x0e8d, 0x0e94, 0x0e97, 0x0e99, 0x0e9f, 0x0ea1, 0x0ea3, 0x0ea5, 0x0ea5, 0x0ea7, 0x0ea7, 0x0eaa, 0x0eab, 0x0ead, 0x0eb0, 0x0eb2, 0x0eb3, 0x0ebd, 0x0ebd, 0x0ec0, 0x0ec4, 0x0ec6, 0x0ec6, 0x0ed0, 0x0ed9, 0x0edc, 0x0edd, 0x0f00, 0x0f17, 0x0f1a, 0x0f34, 0x0f36, 0x0f36, 0x0f38, 0x0f38, 0x0f3e, 0x0f47, 0x0f49, 0x0f6a, 0x0f7f, 0x0f7f, 0x0f85, 0x0f85, 0x0f88, 0x0f8b, 0x0fbe, 0x0fc5, 0x0fc7, 0x0fcc, 0x0fcf, 0x0fcf, 0x1000, 0x1021, 0x1023, 0x1027, 0x1029, 0x102a, 0x102c, 0x102c, 0x1031, 0x1031, 0x1038, 0x1038, 0x1040, 0x1057, 0x10a0, 0x10c5, 0x10d0, 0x10f8, 0x10fb, 0x10fb, 0x1100, 0x1159, 0x115f, 0x11a2, 0x11a8, 0x11f9, 0x1200, 0x1206, 0x1208, 0x1246, 0x1248, 0x1248, 0x124a, 0x124d, 0x1250, 0x1256, 0x1258, 0x1258, 0x125a, 0x125d, 0x1260, 0x1286, 0x1288, 0x1288, 0x128a, 0x128d, 0x1290, 0x12ae, 0x12b0, 0x12b0, 0x12b2, 0x12b5, 0x12b8, 0x12be, 0x12c0, 0x12c0, 0x12c2, 0x12c5, 0x12c8, 0x12ce, 0x12d0, 0x12d6, 0x12d8, 0x12ee, 0x12f0, 0x130e, 0x1310, 0x1310, 0x1312, 0x1315, 0x1318, 0x131e, 0x1320, 0x1346, 0x1348, 0x135a, 0x1361, 0x137c, 0x13a0, 0x13f4, 0x1401, 0x1676, 0x1681, 0x169a, 0x16a0, 0x16f0, 0x1700, 0x170c, 0x170e, 0x1711, 0x1720, 0x1731, 0x1735, 0x1736, 0x1740, 0x1751, 0x1760, 0x176c, 0x176e, 0x1770, 0x1780, 0x17b6, 0x17be, 0x17c5, 0x17c7, 0x17c8, 0x17d4, 0x17da, 0x17dc, 0x17dc, 0x17e0, 0x17e9, 0x1810, 0x1819, 0x1820, 0x1877, 0x1880, 0x18a8, 0x1e00, 0x1e9b, 0x1ea0, 0x1ef9, 0x1f00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fbc, 0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fcc, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fe0, 0x1fec, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ffc, 0x200e, 0x200e, 0x2071, 0x2071, 0x207f, 0x207f, 0x2102, 0x2102, 0x2107, 0x2107, 0x210a, 0x2113, 0x2115, 0x2115, 0x2119, 0x211d, 0x2124, 0x2124, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212d, 0x212f, 0x2131, 0x2133, 0x2139, 0x213d, 0x213f, 0x2145, 0x2149, 0x2160, 0x2183, 0x2336, 0x237a, 0x2395, 0x2395, 0x249c, 0x24e9, 0x3005, 0x3007, 0x3021, 0x3029, 0x3031, 0x3035, 0x3038, 0x303c, 0x3041, 0x3096, 0x309d, 0x309f, 0x30a1, 0x30fa, 0x30fc, 0x30ff, 0x3105, 0x312c, 0x3131, 0x318e, 0x3190, 0x31b7, 0x31f0, 0x321c, 0x3220, 0x3243, 0x3260, 0x327b, 0x327f, 0x32b0, 0x32c0, 0x32cb, 0x32d0, 0x32fe, 0x3300, 0x3376, 0x337b, 0x33dd, 0x33e0, 0x33fe, 0x3400, 0x4db5, 0x4e00, 0x9fa5, 0xa000, 0xa48c, 0xac00, 0xd7a3, 0xd800, 0xfa2d, 0xfa30, 0xfa6a, 0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xff21, 0xff3a, 0xff41, 0xff5a, 0xff66, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf, 0xffd2, 0xffd7, 0xffda, 0xffdc, 0x10300, 0x1031e, 0x10320, 0x10323, 0x10330, 0x1034a, 0x10400, 0x10425, 0x10428, 0x1044d, 0x1d000, 0x1d0f5, 0x1d100, 0x1d126, 0x1d12a, 0x1d166, 0x1d16a, 0x1d172, 0x1d183, 0x1d184, 0x1d18c, 0x1d1a9, 0x1d1ae, 0x1d1dd, 0x1d400, 0x1d454, 0x1d456, 0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4a9, 0x1d4ac, 0x1d4ae, 0x1d4b9, 0x1d4bb, 0x1d4bb, 0x1d4bd, 0x1d4c0, 0x1d4c2, 0x1d4c3, 0x1d4c5, 0x1d505, 0x1d507, 0x1d50a, 0x1d50d, 0x1d514, 0x1d516, 0x1d51c, 0x1d51e, 0x1d539, 0x1d53b, 0x1d53e, 0x1d540, 0x1d544, 0x1d546, 0x1d546, 0x1d54a, 0x1d550, 0x1d552, 0x1d6a3, 0x1d6a8, 0x1d7c9, 0x20000, 0x2a6d6, 0x2f800, 0x2fa1d, 0xf0000, 0xffffd, 0x100000, 0x10fffd];
const isBidirectionalL = character => inRange(character, bidirectional_l);
const mapping2space = isNonASCIISpaceCharacter;
const mapping2nothing = isCommonlyMappedToNothing;
const getCodePoint = character => character.codePointAt(0);
const first = x => x[0];
const last = x => x[x.length - 1];
function toCodePoints(input) {
const codepoints = [];
const size = input.length;
for (let i = 0; i < size; i += 1) {
const before = input.charCodeAt(i);
if (before >= 0xd800 && before <= 0xdbff && size > i + 1) {
const next = input.charCodeAt(i + 1);
if (next >= 0xdc00 && next <= 0xdfff) {
codepoints.push((before - 0xd800) * 0x400 + next - 0xdc00 + 0x10000);
i += 1;
continue;
}
}
codepoints.push(before);
}
return codepoints;
}
function saslprep(input, opts = {}) {
if (typeof input !== 'string') {
throw new TypeError('Expected string.');
}
if (input.length === 0) {
return '';
}
const mapped_input = toCodePoints(input).map(character => mapping2space(character) ? 0x20 : character).filter(character => !mapping2nothing(character));
const normalized_input = String.fromCodePoint.apply(null, mapped_input).normalize('NFKC');
const normalized_map = toCodePoints(normalized_input);
const hasProhibited = normalized_map.some(isProhibitedCharacter);
if (hasProhibited) {
throw new Error('Prohibited character, see https://tools.ietf.org/html/rfc4013#section-2.3');
}
if (opts.allowUnassigned !== true) {
const hasUnassigned = normalized_map.some(isUnassignedCodePoint);
if (hasUnassigned) {
throw new Error('Unassigned code point, see https://tools.ietf.org/html/rfc4013#section-2.5');
}
}
const hasBidiRAL = normalized_map.some(isBidirectionalRAL);
const hasBidiL = normalized_map.some(isBidirectionalL);
if (hasBidiRAL && hasBidiL) {
throw new Error('String must not contain RandALCat and LCat at the same time,' + ' see https://tools.ietf.org/html/rfc3454#section-6');
}
const isFirstBidiRAL = isBidirectionalRAL(getCodePoint(first(normalized_input)));
const isLastBidiRAL = isBidirectionalRAL(getCodePoint(last(normalized_input)));
if (hasBidiRAL && !(isFirstBidiRAL && isLastBidiRAL)) {
throw new Error('Bidirectional RandALCat character must be the first and the last' + ' character of the string, see https://tools.ietf.org/html/rfc3454#section-6');
}
return normalized_input;
}
class PDFSecurity {
static generateFileID(info = {}) {
let infoStr = `${info.CreationDate.getTime()}\n`;
for (let key in info) {
if (!info.hasOwnProperty(key)) {
continue;
}
infoStr += `${key}: ${info[key].valueOf()}\n`;
}
return md5Hash(infoStr);
}
static generateRandomWordArray(bytes) {
return randomBytes(bytes);
}
static create(document, options = {}) {
if (!options.ownerPassword && !options.userPassword) {
return null;
}
return new PDFSecurity(document, options);
}
constructor(document, options = {}) {
if (!options.ownerPassword && !options.userPassword) {
throw new Error('None of owner password and user password is defined.');
}
this.document = document;
this._setupEncryption(options);
}
_setupEncryption(options) {
switch (options.pdfVersion) {
case '1.4':
case '1.5':
this.version = 2;
break;
case '1.6':
case '1.7':
this.version = 4;
break;
case '1.7ext3':
this.version = 5;
break;
default:
this.version = 1;
break;
}
const encDict = {
Filter: 'Standard'
};
switch (this.version) {
case 1:
case 2:
case 4:
this._setupEncryptionV1V2V4(this.version, encDict, options);
break;
case 5:
this._setupEncryptionV5(encDict, options);
break;
}
this.dictionary = this.document.ref(encDict);
}
_setupEncryptionV1V2V4(v, encDict, options) {
let r, permissions;
switch (v) {
case 1:
r = 2;
this.keyBits = 40;
permissions = getPermissionsR2(options.permissions);
break;
case 2:
r = 3;
this.keyBits = 128;
permissions = getPermissionsR3(options.permissions);
break;
case 4:
r = 4;
this.keyBits = 128;
permissions = getPermissionsR3(options.permissions);
break;
}
const paddedUserPassword = processPasswordR2R3R4(options.userPassword);
const paddedOwnerPassword = options.ownerPassword ? processPasswordR2R3R4(options.ownerPassword) : paddedUserPassword;
const ownerPasswordEntry = getOwnerPasswordR2R3R4(r, this.keyBits, paddedUserPassword, paddedOwnerPassword);
this.encryptionKey = getEncryptionKeyR2R3R4(r, this.keyBits, this.document._id, paddedUserPassword, ownerPasswordEntry, permissions);
let userPasswordEntry;
if (r === 2) {
userPasswordEntry = getUserPasswordR2(this.encryptionKey);
} else {
userPasswordEntry = getUserPasswordR3R4(this.document._id, this.encryptionKey);
}
encDict.V = v;
if (v >= 2) {
encDict.Length = this.keyBits;
}
if (v === 4) {
encDict.CF = {
StdCF: {
AuthEvent: 'DocOpen',
CFM: 'AESV2',
Length: this.keyBits / 8
}
};
encDict.StmF = 'StdCF';
encDict.StrF = 'StdCF';
}
encDict.R = r;
encDict.O = ownerPasswordEntry;
encDict.U = userPasswordEntry;
encDict.P = permissions;
}
_setupEncryptionV5(encDict, options) {
this.keyBits = 256;
const permissions = getPermissionsR3(options.permissions);
const processedUserPassword = processPasswordR5(options.userPassword);
const processedOwnerPassword = options.ownerPassword ? processPasswordR5(options.ownerPassword) : processedUserPassword;
this.encryptionKey = getEncryptionKeyR5(PDFSecurity.generateRandomWordArray);
const userPasswordEntry = getUserPasswordR5(processedUserPassword, PDFSecurity.generateRandomWordArray);
const userKeySalt = userPasswordEntry.slice(40, 48);
const userEncryptionKeyEntry = getUserEncryptionKeyR5(processedUserPassword, userKeySalt, this.encryptionKey);
const ownerPasswordEntry = getOwnerPasswordR5(processedOwnerPassword, userPasswordEntry, PDFSecurity.generateRandomWordArray);
const ownerKeySalt = ownerPasswordEntry.slice(40, 48);
const ownerEncryptionKeyEntry = getOwnerEncryptionKeyR5(processedOwnerPassword, ownerKeySalt, userPasswordEntry, this.encryptionKey);
const permsEntry = getEncryptedPermissionsR5(permissions, this.encryptionKey, PDFSecurity.generateRandomWordArray);
encDict.V = 5;
encDict.Length = this.keyBits;
encDict.CF = {
StdCF: {
AuthEvent: 'DocOpen',
CFM: 'AESV3',
Length: this.keyBits / 8
}
};
encDict.StmF = 'StdCF';
encDict.StrF = 'StdCF';
encDict.R = 5;
encDict.O = ownerPasswordEntry;
encDict.OE = ownerEncryptionKeyEntry;
encDict.U = userPasswordEntry;
encDict.UE = userEncryptionKeyEntry;
encDict.P = permissions;
encDict.Perms = permsEntry;
}
getEncryptFn(obj, gen) {
let digest;
if (this.version < 5) {
const suffix = new Uint8Array([obj & 0xff, obj >> 8 & 0xff, obj >> 16 & 0xff, gen & 0xff, gen >> 8 & 0xff]);
digest = utils.concatBytes(this.encryptionKey, suffix);
}
if (this.version === 1 || this.version === 2) {
let key = md5Hash(digest);
const keyLen = Math.min(16, this.keyBits / 8 + 5);
key = key.slice(0, keyLen);
return buffer => rc4(buffer, key);
}
let key;
if (this.version === 4) {
const saltMarker = new Uint8Array([0x73, 0x41, 0x6c, 0x54]);
key = md5Hash(utils.concatBytes(digest, saltMarker));
} else {
key = this.encryptionKey;
}
const iv = PDFSecurity.generateRandomWordArray(16);
return buffer => {
const encrypted = aesCbcEncrypt(buffer, key, iv, true);
return utils.concatBytes(iv, encrypted);
};
}
end() {
this.dictionary.end();
}
}
function getPermissionsR2(permissionObject = {}) {
let permissions = 0xffffffc0 >> 0;
if (permissionObject.printing) {
permissions |= 0b000000000100;
}
if (permissionObject.modifying) {
permissions |= 0b000000001000;
}
if (permissionObject.copying) {
permissions |= 0b000000010000;
}
if (permissionObject.annotating) {
permissions |= 0b000000100000;
}
return permissions;
}
function getPermissionsR3(permissionObject = {}) {
let permissions = 0xfffff0c0 >> 0;
if (permissionObject.printing === 'lowResolution') {
permissions |= 0b000000000100;
}
if (permissionObject.printing === 'highResolution') {
permissions |= 0b100000000100;
}
if (permissionObject.modifying) {
permissions |= 0b000000001000;
}
if (permissionObject.copying) {
permissions |= 0b000000010000;
}
if (permissionObject.annotating) {
permissions |= 0b000000100000;
}
if (permissionObject.fillingForms) {
permissions |= 0b000100000000;
}
if (permissionObject.contentAccessibility) {
permissions |= 0b001000000000;
}
if (permissionObject.documentAssembly) {
permissions |= 0b010000000000;
}
return permissions;
}
function getUserPasswordR2(encryptionKey) {
return rc4(processPasswordR2R3R4(), encryptionKey);
}
function getUserPasswordR3R4(documentId, encryptionKey) {
const key = encryptionKey.slice();
let cipher = md5Hash(utils.concatBytes(processPasswordR2R3R4(), new Uint8Array(documentId)));
for (let i = 0; i < 20; i++) {
const xorKey = new Uint8Array(key.length);
for (let j = 0; j < key.length; j++) {
xorKey[j] = encryptionKey[j] ^ i;
}
cipher = rc4(cipher, xorKey);
}
const result = new Uint8Array(32);
result.set(cipher);
return result;
}
function getOwnerPasswordR2R3R4(r, keyBits, paddedUserPassword, paddedOwnerPassword) {
let digest = paddedOwnerPassword;
let round = r >= 3 ? 51 : 1;
for (let i = 0; i < round; i++) {
digest = md5Hash(digest);
}
const keyLen = keyBits / 8;
let key = digest.slice(0, keyLen);
let cipher = paddedUserPassword;
round = r >= 3 ? 20 : 1;
for (let i = 0; i < round; i++) {
const xorKey = new Uint8Array(keyLen);
for (let j = 0; j < keyLen; j++) {
xorKey[j] = key[j] ^ i;
}
cipher = rc4(cipher, xorKey);
}
return cipher;
}
function getEncryptionKeyR2R3R4(r, keyBits, documentId, paddedUserPassword, ownerPasswordEntry, permissions) {
const permBytes = new Uint8Array([permissions & 0xff, permissions >> 8 & 0xff, permissions >> 16 & 0xff, permissions >> 24 & 0xff]);
let key = utils.concatBytes(paddedUserPassword, ownerPasswordEntry, permBytes, new Uint8Array(documentId));
const round = r >= 3 ? 51 : 1;
const keyLen = keyBits / 8;
for (let i = 0; i < round; i++) {
key = md5Hash(key);
key = key.slice(0, keyLen);
}
return key;
}
function getUserPasswordR5(processedUserPassword, generateRandomWordArray) {
const validationSalt = generateRandomWordArray(8);
const keySalt = generateRandomWordArray(8);
const hash = sha256Hash(utils.concatBytes(processedUserPassword, validationSalt));
return utils.concatBytes(hash, validationSalt, keySalt);
}
function getUserEncryptionKeyR5(processedUserPassword, userKeySalt, encryptionKey) {
const key = sha256Hash(utils.concatBytes(processedUserPassword, userKeySalt));
const iv = new Uint8Array(16);
return aesCbcEncrypt(encryptionKey, key, iv, false);
}
function getOwnerPasswordR5(processedOwnerPassword, userPasswordEntry, generateRandomWordArray) {
const validationSalt = generateRandomWordArray(8);
const keySalt = generateRandomWordArray(8);
const hash = sha256Hash(utils.concatBytes(processedOwnerPassword, validationSalt, userPasswordEntry));
return utils.concatBytes(hash, validationSalt, keySalt);
}
function getOwnerEncryptionKeyR5(processedOwnerPassword, ownerKeySalt, userPasswordEntry, encryptionKey) {
const key = sha256Hash(utils.concatBytes(processedOwnerPassword, ownerKeySalt, userPasswordEntry));
const iv = new Uint8Array(16);
return aesCbcEncrypt(encryptionKey, key, iv, false);
}
function getEncryptionKeyR5(generateRandomWordArray) {
return generateRandomWordArray(32);
}
function getEncryptedPermissionsR5(permissions, encryptionKey, generateRandomWordArray) {
const data = new Uint8Array(16);
data[0] = permissions & 0xff;
data[1] = permissions >> 8 & 0xff;
data[2] = permissions >> 16 & 0xff;
data[3] = permissions >> 24 & 0xff;
data[4] = 0xff;
data[5] = 0xff;
data[6] = 0xff;
data[7] = 0xff;
data[8] = 0x54;
data[9] = 0x61;
data[10] = 0x64;
data[11] = 0x62;
const randomPart = generateRandomWordArray(4);
data.set(randomPart, 12);
return aesEcbEncrypt(data, encryptionKey);
}
function processPasswordR2R3R4(password = '') {
const out = new Uint8Array(32);
const length = password.length;
let index = 0;
while (index < length && index < 32) {
const code = password.charCodeAt(index);
if (code > 0xff) {
throw new Error('Password contains one or more invalid characters.');
}
out[index] = code;
index++;
}
while (index < 32) {
out[index] = PASSWORD_PADDING[index - length];
index++;
}
return out;
}
function processPasswordR5(password = '') {
password = unescape(encodeURIComponent(saslprep(password)));
const length = Math.min(127, password.length);
const out = new Uint8Array(length);
for (let i = 0; i < length; i++) {
out[i] = password.charCodeAt(i);
}
return out;
}
const PASSWORD_PADDING = [0x28, 0xbf, 0x4e, 0x5e, 0x4e, 0x75, 0x8a, 0x41, 0x64, 0x00, 0x4e, 0x56, 0xff, 0xfa, 0x01, 0x08, 0x2e, 0x2e, 0x00, 0xb6, 0xd0, 0x68, 0x3e, 0x80, 0x2f, 0x0c, 0xa9, 0xfe, 0x64, 0x53, 0x69, 0x7a];
const {
number: number$2
} = PDFObject;
let PDFGradient$1 = class PDFGradient {
constructor(doc) {
this.doc = doc;
this.stops = [];
this.embedded = false;
this.transform = [1, 0, 0, 1, 0, 0];
}
stop(pos, color, opacity) {
if (opacity == null) {
opacity = 1;
}
color = this.doc._normalizeColor(color);
if (this.stops.length === 0) {
if (color.length === 3) {
this._colorSpace = 'DeviceRGB';
} else if (color.length === 4) {
this._colorSpace = 'DeviceCMYK';
} else if (color.length === 1) {
this._colorSpace = 'DeviceGray';
} else {
throw new Error('Unknown color space');
}
} else if (this._colorSpace === 'DeviceRGB' && color.length !== 3 || this._colorSpace === 'DeviceCMYK' && color.length !== 4 || this._colorSpace === 'DeviceGray' && color.length !== 1) {
throw new Error('All gradient stops must use the same color space');
}
opacity = Math.max(0, Math.min(1, opacity));
this.stops.push([pos, color, opacity]);
return this;
}
setTransform(m11, m12, m21, m22, dx, dy) {
this.transform = [m11, m12, m21, m22, dx, dy];
return this;
}
embed(m) {
let fn;
const stopsLength = this.stops.length;
if (stopsLength === 0) {
return;
}
this.embedded = true;
this.matrix = m;
const last = this.stops[stopsLength - 1];
if (last[0] < 1) {
this.stops.push([1, last[1], last[2]]);
}
const bounds = [];
const encode = [];
const stops = [];
for (let i = 0; i < stopsLength - 1; i++) {
encode.push(0, 1);
if (i + 2 !== stopsLength) {
bounds.push(this.stops[i + 1][0]);
}
fn = this.doc.ref({
FunctionType: 2,
Domain: [0, 1],
C0: this.stops[i + 0][1],
C1: this.stops[i + 1][1],
N: 1
});
stops.push(fn);
fn.end();
}
if (stopsLength === 1) {
fn = stops[0];
} else {
fn = this.doc.ref({
FunctionType: 3,
Domain: [0, 1],
Functions: stops,
Bounds: bounds,
Encode: encode
});
fn.end();
}
this.id = `Sh${++this.doc._gradCount}`;
const shader = this.shader(fn);
shader.end();
const pattern = this.doc.ref({
Type: 'Pattern',
PatternType: 2,
Shading: shader,
Matrix: this.matrix.map(number$2)
});
pattern.end();
if (this.stops.some(stop => stop[2] < 1)) {
let grad = this.opacityGradient();
grad._colorSpace = 'DeviceGray';
for (let stop of this.stops) {
grad.stop(stop[0], [stop[2]]);
}
grad = grad.embed(this.matrix);
const pageBBox = [0, 0, this.doc.page.width, this.doc.page.height];
const form = this.doc.ref({
Type: 'XObject',
Subtype: 'Form',
FormType: 1,
BBox: pageBBox,
Group: {
Type: 'Group',
S: 'Transparency',
CS: 'DeviceGray'
},
Resources: {
ProcSet: ['PDF', 'Text', 'ImageB', 'ImageC', 'ImageI'],
Pattern: {
Sh1: grad
}
}
});
form.write('/Pattern cs /Sh1 scn');
form.end(`${pageBBox.join(' ')} re f`);
const gstate = this.doc.ref({
Type: 'ExtGState',
SMask: {
Type: 'Mask',
S: 'Luminosity',
G: form
}
});
gstate.end();
const opacityPattern = this.doc.ref({
Type: 'Pattern',
PatternType: 1,
PaintType: 1,
TilingType: 2,
BBox: pageBBox,
XStep: pageBBox[2],
YStep: pageBBox[3],
Resources: {
ProcSet: ['PDF', 'Text', 'ImageB', 'ImageC', 'ImageI'],
Pattern: {
Sh1: pattern
},
ExtGState: {
Gs1: gstate
}
}
});
opacityPattern.write('/Gs1 gs /Pattern cs /Sh1 scn');
opacityPattern.end(`${pageBBox.join(' ')} re f`);
this.doc.page.patterns[this.id] = opacityPattern;
} else {
this.doc.page.patterns[this.id] = pattern;
}
return pattern;
}
apply(stroke) {
const [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
const [m11, m12, m21, m22, dx, dy] = this.transform;
const m = [m0 * m11 + m2 * m12, m1 * m11 + m3 * m12, m0 * m21 + m2 * m22, m1 * m21 + m3 * m22, m0 * dx + m2 * dy + m4, m1 * dx + m3 * dy + m5];
if (!this.embedded || m.join(' ') !== this.matrix.join(' ')) {
this.embed(m);
}
this.doc._setColorSpace('Pattern', stroke);
const op = stroke ? 'SCN' : 'scn';
return this.doc.addContent(`/${this.id} ${op}`);
}
};
let PDFLinearGradient$1 = class PDFLinearGradient extends PDFGradient$1 {
constructor(doc, x1, y1, x2, y2) {
super(doc);
this.x1 = x1;
this.y1 = y1;
this.x2 = x2;
this.y2 = y2;
}
shader(fn) {
return this.doc.ref({
ShadingType: 2,
ColorSpace: this._colorSpace,
Coords: [this.x1, this.y1, this.x2, this.y2],
Function: fn,
Extend: [true, true]
});
}
opacityGradient() {
return new PDFLinearGradient(this.doc, this.x1, this.y1, this.x2, this.y2);
}
};
let PDFRadialGradient$1 = class PDFRadialGradient extends PDFGradient$1 {
constructor(doc, x1, y1, r1, x2, y2, r2) {
super(doc);
this.doc = doc;
this.x1 = x1;
this.y1 = y1;
this.r1 = r1;
this.x2 = x2;
this.y2 = y2;
this.r2 = r2;
}
shader(fn) {
return this.doc.ref({
ShadingType: 3,
ColorSpace: this._colorSpace,
Coords: [this.x1, this.y1, this.r1, this.x2, this.y2, this.r2],
Function: fn,
Extend: [true, true]
});
}
opacityGradient() {
return new PDFRadialGradient(this.doc, this.x1, this.y1, this.r1, this.x2, this.y2, this.r2);
}
};
var Gradient = {
PDFGradient: PDFGradient$1,
PDFLinearGradient: PDFLinearGradient$1,
PDFRadialGradient: PDFRadialGradient$1
};
const underlyingColorSpaces = ['DeviceCMYK', 'DeviceRGB'];
let PDFTilingPattern$1 = class PDFTilingPattern {
constructor(doc, bBox, xStep, yStep, stream) {
this.doc = doc;
this.bBox = bBox;
this.xStep = xStep;
this.yStep = yStep;
this.stream = stream;
}
createPattern() {
const resources = this.doc.ref();
resources.end();
const [m0, m1, m2, m3, m4, m5] = this.doc._ctm;
const [m11, m12, m21, m22, dx, dy] = [1, 0, 0, 1, 0, 0];
const m = [m0 * m11 + m2 * m12, m1 * m11 + m3 * m12, m0 * m21 + m2 * m22, m1 * m21 + m3 * m22, m0 * dx + m2 * dy + m4, m1 * dx + m3 * dy + m5];
const pattern = this.doc.ref({
Type: 'Pattern',
PatternType: 1,
PaintType: 2,
TilingType: 2,
BBox: this.bBox,
XStep: this.xStep,
YStep: this.yStep,
Matrix: m.map(v => +v.toFixed(5)),
Resources: resources
});
pattern.end(this.stream);
return pattern;
}
embedPatternColorSpaces() {
underlyingColorSpaces.forEach(csName => {
const csId = this.getPatternColorSpaceId(csName);
if (this.doc.page.colorSpaces[csId]) return;
const cs = this.doc.ref(['Pattern', csName]);
cs.end();
this.doc.page.colorSpaces[csId] = cs;
});
}
getPatternColorSpaceId(underlyingColorspace) {
return `CsP${underlyingColorspace}`;
}
embed() {
if (!this.id) {
this.doc._patternCount = this.doc._patternCount + 1;
this.id = 'P' + this.doc._patternCount;
this.pattern = this.createPattern();
}
if (!this.doc.page.patterns[this.id]) {
this.doc.page.patterns[this.id] = this.pattern;
}
}
apply(stroke, patternColor) {
this.embedPatternColorSpaces();
this.embed();
const normalizedColor = this.doc._normalizeColor(patternColor);
if (!normalizedColor) throw Error(`invalid pattern color. (value: ${patternColor})`);
const csId = this.getPatternColorSpaceId(this.doc._getColorSpace(normalizedColor));
this.doc._setColorSpace(csId, stroke);
const op = stroke ? 'SCN' : 'scn';
return this.doc.addContent(`${normalizedColor.join(' ')} /${this.id} ${op}`);
}
};
var pattern = {
PDFTilingPattern: PDFTilingPattern$1
};
const {
PDFGradient,
PDFLinearGradient,
PDFRadialGradient
} = Gradient;
const {
PDFTilingPattern
} = pattern;
var ColorMixin = {
initColor() {
this.spotColors = {};
this._opacityRegistry = {};
this._opacityCount = 0;
this._patternCount = 0;
this._gradCount = 0;
},
_normalizeColor(color) {
if (typeof color === 'string') {
if (color.charAt(0) === '#') {
if (color.length === 4) {
color = color.replace(/#([0-9A-F])([0-9A-F])([0-9A-F])/i, '#$1$1$2$2$3$3');
}
const hex = parseInt(color.slice(1), 16);
color = [hex >> 16, hex >> 8 & 0xff, hex & 0xff];
} else if (namedColors[color]) {
color = namedColors[color];
} else if (this.spotColors[color]) {
return this.spotColors[color];
}
}
if (Array.isArray(color)) {
if (color.length === 3) {
color = color.map(part => part / 255);
} else if (color.length === 4) {
color = color.map(part => part / 100);
}
return color;
}
return null;
},
_setColor(color, stroke) {
if (color instanceof PDFGradient) {
color.apply(stroke);
return true;
} else if (Array.isArray(color) && color[0] instanceof PDFTilingPattern) {
color[0].apply(stroke, color[1]);
return true;
}
return this._setColorCore(color, stroke);
},
_setColorCore(color, stroke) {
color = this._normalizeColor(color);
if (!color) {
return false;
}
const op = stroke ? 'SCN' : 'scn';
const space = this._getColorSpace(color);
this._setColorSpace(space, stroke);
if (color instanceof SpotColor) {
this.page.colorSpaces[color.id] = color.ref;
this.addContent(`1 ${op}`);
} else {
this.addContent(`${color.join(' ')} ${op}`);
}
return true;
},
_setColorSpace(space, stroke) {
const op = stroke ? 'CS' : 'cs';
return this.addContent(`/${space} ${op}`);
},
_getColorSpace(color) {
if (color instanceof SpotColor) {
return color.id;
}
return color.length === 4 ? 'DeviceCMYK' : 'DeviceRGB';
},
fillColor(color, opacity) {
const set = this._setColor(color, false);
if (set) {
this.fillOpacity(opacity);
}
this._fillColor = [color, opacity];
return this;
},
strokeColor(color, opacity) {
const set = this._setColor(color, true);
if (set) {
this.strokeOpacity(opacity);
}
return this;
},
opacity(opacity) {
this._doOpacity(opacity, opacity);
return this;
},
fillOpacity(opacity) {
this._doOpacity(opacity, null);
return this;
},
strokeOpacity(opacity) {
this._doOpacity(null, opacity);
return this;
},
_doOpacity(fillOpacity, strokeOpacity) {
let dictionary, name;
if (fillOpacity == null && strokeOpacity == null) {
return;
}
if (fillOpacity != null) {
fillOpacity = Math.max(0, Math.min(1, fillOpacity));
}
if (strokeOpacity != null) {
strokeOpacity = Math.max(0, Math.min(1, strokeOpacity));
}
const key = `${fillOpacity}_${strokeOpacity}`;
if (this._opacityRegistry[key]) {
[dictionary, name] = this._opacityRegistry[key];
} else {
dictionary = {
Type: 'ExtGState'
};
if (fillOpacity != null) {
dictionary.ca = fillOpacity;
}
if (strokeOpacity != null) {
dictionary.CA = strokeOpacity;
}
dictionary = this.ref(dictionary);
dictionary.end();
const id = ++this._opacityCount;
name = `Gs${id}`;
this._opacityRegistry[key] = [dictionary, name];
}
this.page.ext_gstates[name] = dictionary;
return this.addContent(`/${name} gs`);
},
linearGradient(x1, y1, x2, y2) {
return new PDFLinearGradient(this, x1, y1, x2, y2);
},
radialGradient(x1, y1, r1, x2, y2, r2) {
return new PDFRadialGradient(this, x1, y1, r1, x2, y2, r2);
},
pattern(bbox, xStep, yStep, stream) {
return new PDFTilingPattern(this, bbox, xStep, yStep, stream);
},
addSpotColor(name, C, M, Y, K) {
const color = new SpotColor(this, name, C, M, Y, K);
this.spotColors[name] = color;
return this;
}
};
var 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],
darkgreen: [0, 100, 0],
darkgrey: [169, 169, 169],
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],
lightgreen: [144, 238, 144],
lightgrey: [211, 211, 211],
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],
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],
yellowgreen: [154, 205, 50]
};
let cx, cy, px, py, sx, sy;
cx = cy = px = py = sx = sy = 0;
const parameters = {
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 isCommand = function (c) {
return c in parameters;
};
const isWsp = function (c) {
const codePoint = c.codePointAt(0);
return codePoint === 0x20 || codePoint === 0x9 || codePoint === 0xd || codePoint === 0xa;
};
const isDigit = function (c) {
const codePoint = c.codePointAt(0);
if (codePoint == null) {
return false;
}
return 48 <= codePoint && codePoint <= 57;
};
const readNumber = function (string, cursor) {
let i = cursor;
let value = '';
let state = 'none';
for (; i < string.length; i += 1) {
const c = string[i];
if (c === '+' || c === '-') {
if (state === 'none') {
state = 'sign';
value += c;
continue;
}
if (state === 'e') {
state = 'exponent_sign';
value += c;
continue;
}
}
if (isDigit(c)) {
if (state === 'none' || state === 'sign' || state === 'whole') {
state = 'whole';
value += c;
continue;
}
if (state === 'decimal_point' || state === 'decimal') {
state = 'decimal';
value += c;
continue;
}
if (state === 'e' || state === 'exponent_sign' || state === 'exponent') {
state = 'exponent';
value += c;
continue;
}
}
if (c === '.') {
if (state === 'none' || state === 'sign' || state === 'whole') {
state = 'decimal_point';
value += c;
continue;
}
}
if (c === 'E' || c === 'e') {
if (state === 'whole' || state === 'decimal_point' || state === 'decimal') {
state = 'e';
value += c;
continue;
}
}
break;
}
const number = Number.parseFloat(value);
if (Number.isNaN(number)) {
return [cursor, null];
}
return [i - 1, number];
};
const parse = function (path) {
const pathData = [];
let command = null;
let args = [];
let argsCount = 0;
let canHaveComma = false;
let hadComma = false;
for (let i = 0; i < path.length; i += 1) {
const c = path.charAt(i);
if (isWsp(c)) {
continue;
}
if (canHaveComma && c === ',') {
if (hadComma) {
break;
}
hadComma = true;
continue;
}
if (isCommand(c)) {
if (hadComma) {
return pathData;
}
if (command == null) {
if (c !== 'M' && c !== 'm') {
return pathData;
}
} else {
if (args.length !== 0) {
return pathData;
}
}
command = c;
args = [];
argsCount = parameters[command];
canHaveComma = false;
if (argsCount === 0) {
pathData.push({
command,
args
});
}
continue;
}
if (command == null) {
return pathData;
}
let newCursor = i;
let number = null;
if (command === 'A' || command === 'a') {
const position = args.length;
if (position === 0 || position === 1) {
if (c !== '+' && c !== '-') {
[newCursor, number] = readNumber(path, i);
}
}
if (position === 2 || position === 5 || position === 6) {
[newCursor, number] = readNumber(path, i);
}
if (position === 3 || position === 4) {
if (c === '0') {
number = 0;
}
if (c === '1') {
number = 1;
}
}
} else {
[newCursor, number] = readNumber(path, i);
}
if (number == null) {
return pathData;
}
args.push(number);
canHaveComma = true;
hadComma = false;
i = newCursor;
if (args.length === argsCount) {
pathData.push({
command,
args
});
if (command === 'M') {
command = 'L';
}
if (command === 'm') {
command = 'l';
}
args = [];
}
}
return pathData;
};
const apply = function (commands, doc) {
cx = cy = px = py = sx = sy = 0;
for (let i = 0; i < commands.length; i++) {
const c = commands[i];
if (typeof runners[c.command] === 'function') {
runners[c.command](doc, c.args);
}
}
};
const runners = {
M(doc, a) {
cx = a[0];
cy = a[1];
px = py = null;
sx = cx;
sy = cy;
return doc.moveTo(cx, cy);
},
m(doc, a) {
cx += a[0];
cy += a[1];
px = py = null;
sx = cx;
sy = cy;
return doc.moveTo(cx, cy);
},
C(doc, a) {
cx = a[4];
cy = a[5];
px = a[2];
py = a[3];
return doc.bezierCurveTo(...a);
},
c(doc, a) {
doc.bezierCurveTo(a[0] + cx, a[1] + cy, a[2] + cx, a[3] + cy, a[4] + cx, a[5] + cy);
px = cx + a[2];
py = cy + a[3];
cx += a[4];
return cy += a[5];
},
S(doc, a) {
if (px === null) {
px = cx;
py = cy;
}
doc.bezierCurveTo(cx - (px - cx), cy - (py - cy), a[0], a[1], a[2], a[3]);
px = a[0];
py = a[1];
cx = a[2];
return cy = a[3];
},
s(doc, a) {
if (px === null) {
px = cx;
py = cy;
}
doc.bezierCurveTo(cx - (px - cx), cy - (py - cy), cx + a[0], cy + a[1], cx + a[2], cy + a[3]);
px = cx + a[0];
py = cy + a[1];
cx += a[2];
return cy += a[3];
},
Q(doc, a) {
px = a[0];
py = a[1];
cx = a[2];
cy = a[3];
return doc.quadraticCurveTo(a[0], a[1], cx, cy);
},
q(doc, a) {
doc.quadraticCurveTo(a[0] + cx, a[1] + cy, a[2] + cx, a[3] + cy);
px = cx + a[0];
py = cy + a[1];
cx += a[2];
return cy += a[3];
},
T(doc, a) {
if (px === null) {
px = cx;
py = cy;
} else {
px = cx - (px - cx);
py = cy - (py - cy);
}
doc.quadraticCurveTo(px, py, a[0], a[1]);
px = cx - (px - cx);
py = cy - (py - cy);
cx = a[0];
return cy = a[1];
},
t(doc, a) {
if (px === null) {
px = cx;
py = cy;
} else {
px = cx - (px - cx);
py = cy - (py - cy);
}
doc.quadraticCurveTo(px, py, cx + a[0], cy + a[1]);
cx += a[0];
return cy += a[1];
},
A(doc, a) {
solveArc(doc, cx, cy, a);
cx = a[5];
return cy = a[6];
},
a(doc, a) {
a[5] += cx;
a[6] += cy;
solveArc(doc, cx, cy, a);
cx = a[5];
return cy = a[6];
},
L(doc, a) {
cx = a[0];
cy = a[1];
px = py = null;
return doc.lineTo(cx, cy);
},
l(doc, a) {
cx += a[0];
cy += a[1];
px = py = null;
return doc.lineTo(cx, cy);
},
H(doc, a) {
cx = a[0];
px = py = null;
return doc.lineTo(cx, cy);
},
h(doc, a) {
cx += a[0];
px = py = null;
return doc.lineTo(cx, cy);
},
V(doc, a) {
cy = a[0];
px = py = null;
return doc.lineTo(cx, cy);
},
v(doc, a) {
cy += a[0];
px = py = null;
return doc.lineTo(cx, cy);
},
Z(doc) {
doc.closePath();
cx = sx;
return cy = sy;
},
z(doc) {
doc.closePath();
cx = sx;
return cy = sy;
}
};
const solveArc = function (doc, x, y, coords) {
const [rx, ry, rot, large, sweep, ex, ey] = coords;
const segs = arcToSegments(ex, ey, rx, ry, large, sweep, rot, x, y);
for (let seg of segs) {
const bez = segmentToBezier(...seg);
doc.bezierCurveTo(...bez);
}
};
const arcToSegments = function (x, y, rx, ry, large, sweep, rotateX, ox, oy) {
const th = rotateX * (Math.PI / 180);
const sin_th = Math.sin(th);
const cos_th = Math.cos(th);
rx = Math.abs(rx);
ry = Math.abs(ry);
px = cos_th * (ox - x) * 0.5 + sin_th * (oy - y) * 0.5;
py = cos_th * (oy - y) * 0.5 - sin_th * (ox - x) * 0.5;
let pl = px * px / (rx * rx) + py * py / (ry * ry);
if (pl > 1) {
pl = Math.sqrt(pl);
rx *= pl;
ry *= pl;
}
const a00 = cos_th / rx;
const a01 = sin_th / rx;
const a10 = -sin_th / ry;
const a11 = cos_th / ry;
const x0 = a00 * ox + a01 * oy;
const y0 = a10 * ox + a11 * oy;
const x1 = a00 * x + a01 * y;
const y1 = a10 * x + a11 * y;
const d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
let sfactor_sq = 1 / d - 0.25;
if (sfactor_sq < 0) {
sfactor_sq = 0;
}
let sfactor = Math.sqrt(sfactor_sq);
if (sweep === large) {
sfactor = -sfactor;
}
const xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0);
const yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0);
const th0 = Math.atan2(y0 - yc, x0 - xc);
const th1 = Math.atan2(y1 - yc, x1 - xc);
let th_arc = th1 - th0;
if (th_arc < 0 && sweep === 1) {
th_arc += 2 * Math.PI;
} else if (th_arc > 0 && sweep === 0) {
th_arc -= 2 * Math.PI;
}
const segments = Math.ceil(Math.abs(th_arc / (Math.PI * 0.5 + 0.001)));
const result = [];
for (let i = 0; i < segments; i++) {
const th2 = th0 + i * th_arc / segments;
const th3 = th0 + (i + 1) * th_arc / segments;
result[i] = [xc, yc, th2, th3, rx, ry, sin_th, cos_th];
}
return result;
};
const segmentToBezier = function (cx, cy, th0, th1, rx, ry, sin_th, cos_th) {
const a00 = cos_th * rx;
const a01 = -sin_th * ry;
const a10 = sin_th * rx;
const a11 = cos_th * ry;
const th_half = 0.5 * (th1 - th0);
const t = 8 / 3 * Math.sin(th_half * 0.5) * Math.sin(th_half * 0.5) / Math.sin(th_half);
const x1 = cx + Math.cos(th0) - t * Math.sin(th0);
const y1 = cy + Math.sin(th0) + t * Math.cos(th0);
const x3 = cx + Math.cos(th1);
const y3 = cy + Math.sin(th1);
const x2 = x3 + t * Math.sin(th1);
const y2 = y3 - t * Math.cos(th1);
return [a00 * x1 + a01 * y1, a10 * x1 + a11 * y1, a00 * x2 + a01 * y2, a10 * x2 + a11 * y2, a00 * x3 + a01 * y3, a10 * x3 + a11 * y3];
};
class SVGPath {
static apply(doc, path) {
const commands = parse(path);
apply(commands, doc);
}
}
const {
number: number$1
} = PDFObject;
const KAPPA = 4.0 * ((Math.sqrt(2) - 1.0) / 3.0);
var VectorMixin = {
initVector() {
this._ctm = [1, 0, 0, 1, 0, 0];
this._ctmStack = [];
},
save() {
this._ctmStack.push(this._ctm.slice());
return this.addContent('q');
},
restore() {
this._ctm = this._ctmStack.pop() || [1, 0, 0, 1, 0, 0];
return this.addContent('Q');
},
closePath() {
return this.addContent('h');
},
lineWidth(w) {
return this.addContent(`${number$1(w)} w`);
},
_CAP_STYLES: {
BUTT: 0,
ROUND: 1,
SQUARE: 2
},
lineCap(c) {
if (typeof c === 'string') {
c = this._CAP_STYLES[c.toUpperCase()];
}
return this.addContent(`${c} J`);
},
_JOIN_STYLES: {
MITER: 0,
ROUND: 1,
BEVEL: 2
},
lineJoin(j) {
if (typeof j === 'string') {
j = this._JOIN_STYLES[j.toUpperCase()];
}
return this.addContent(`${j} j`);
},
miterLimit(m) {
return this.addContent(`${number$1(m)} M`);
},
dash(length, options = {}) {
const originalLength = length;
if (!Array.isArray(length)) {
length = [length, options.space || length];
}
const valid = length.every(x => Number.isFinite(x) && x > 0);
if (!valid) {
throw new Error(`dash(${JSON.stringify(originalLength)}, ${JSON.stringify(options)}) invalid, lengths must be numeric and greater than zero`);
}
length = length.map(number$1).join(' ');
return this.addContent(`[${length}] ${number$1(options.phase || 0)} d`);
},
undash() {
return this.addContent('[] 0 d');
},
moveTo(x, y) {
return this.addContent(`${number$1(x)} ${number$1(y)} m`);
},
lineTo(x, y) {
return this.addContent(`${number$1(x)} ${number$1(y)} l`);
},
bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
return this.addContent(`${number$1(cp1x)} ${number$1(cp1y)} ${number$1(cp2x)} ${number$1(cp2y)} ${number$1(x)} ${number$1(y)} c`);
},
quadraticCurveTo(cpx, cpy, x, y) {
return this.addContent(`${number$1(cpx)} ${number$1(cpy)} ${number$1(x)} ${number$1(y)} v`);
},
rect(x, y, w, h) {
return this.addContent(`${number$1(x)} ${number$1(y)} ${number$1(w)} ${number$1(h)} re`);
},
roundedRect(x, y, w, h, borderRadius) {
if (borderRadius == null) {
borderRadius = 0;
}
let radii;
if (Array.isArray(borderRadius)) {
radii = borderRadius.slice(0, 4);
} else {
radii = [borderRadius, borderRadius, borderRadius, borderRadius];
}
const limit = Math.min(0.5 * w, 0.5 * h);
const rTL = Math.max(0, Math.min(radii[0] || 0, limit));
const rTR = Math.max(0, Math.min(radii[1] || 0, limit));
const rBR = Math.max(0, Math.min(radii[2] || 0, limit));
const rBL = Math.max(0, Math.min(radii[3] || 0, limit));
const cpTR = rTR * (1.0 - KAPPA);
const cpBR = rBR * (1.0 - KAPPA);
const cpBL = rBL * (1.0 - KAPPA);
const cpTL = rTL * (1.0 - KAPPA);
this.moveTo(x + rTL, y);
this.lineTo(x + w - rTR, y);
if (rTR > 0) {
this.bezierCurveTo(x + w - cpTR, y, x + w, y + cpTR, x + w, y + rTR);
}
this.lineTo(x + w, y + h - rBR);
if (rBR > 0) {
this.bezierCurveTo(x + w, y + h - cpBR, x + w - cpBR, y + h, x + w - rBR, y + h);
}
this.lineTo(x + rBL, y + h);
if (rBL > 0) {
this.bezierCurveTo(x + cpBL, y + h, x, y + h - cpBL, x, y + h - rBL);
}
this.lineTo(x, y + rTL);
if (rTL > 0) {
this.bezierCurveTo(x, y + cpTL, x + cpTL, y, x + rTL, y);
}
return this.closePath();
},
ellipse(x, y, r1, r2) {
if (r2 == null) {
r2 = r1;
}
x -= r1;
y -= r2;
const ox = r1 * KAPPA;
const oy = r2 * KAPPA;
const xe = x + r1 * 2;
const ye = y + r2 * 2;
const xm = x + r1;
const ym = y + r2;
this.moveTo(x, ym);
this.bezierCurveTo(x, ym - oy, xm - ox, y, xm, y);
this.bezierCurveTo(xm + ox, y, xe, ym - oy, xe, ym);
this.bezierCurveTo(xe, ym + oy, xm + ox, ye, xm, ye);
this.bezierCurveTo(xm - ox, ye, x, ym + oy, x, ym);
return this.closePath();
},
circle(x, y, radius) {
return this.ellipse(x, y, radius);
},
arc(x, y, radius, startAngle, endAngle, anticlockwise) {
if (anticlockwise == null) {
anticlockwise = false;
}
const TWO_PI = 2.0 * Math.PI;
const HALF_PI = 0.5 * Math.PI;
let deltaAng = endAngle - startAngle;
if (Math.abs(deltaAng) > TWO_PI) {
deltaAng = TWO_PI;
} else if (deltaAng !== 0 && anticlockwise !== deltaAng < 0) {
const dir = anticlockwise ? -1 : 1;
deltaAng = dir * TWO_PI + deltaAng;
}
const numSegs = Math.ceil(Math.abs(deltaAng) / HALF_PI);
const segAng = deltaAng / numSegs;
const handleLen = segAng / HALF_PI * KAPPA * radius;
let curAng = startAngle;
let deltaCx = -Math.sin(curAng) * handleLen;
let deltaCy = Math.cos(curAng) * handleLen;
let ax = x + Math.cos(curAng) * radius;
let ay = y + Math.sin(curAng) * radius;
this.moveTo(ax, ay);
for (let segIdx = 0; segIdx < numSegs; segIdx++) {
const cp1x = ax + deltaCx;
const cp1y = ay + deltaCy;
curAng += segAng;
ax = x + Math.cos(curAng) * radius;
ay = y + Math.sin(curAng) * radius;
deltaCx = -Math.sin(curAng) * handleLen;
deltaCy = Math.cos(curAng) * handleLen;
const cp2x = ax - deltaCx;
const cp2y = ay - deltaCy;
this.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, ax, ay);
}
return this;
},
polygon(...points) {
this.moveTo(...(points.shift() || []));
for (let point of points) {
this.lineTo(...(point || []));
}
return this.closePath();
},
path(path) {
SVGPath.apply(this, path);
return this;
},
_windingRule(rule) {
if (/even-?odd/.test(rule)) {
return '*';
}
return '';
},
fill(color, rule) {
if (/(even-?odd)|(non-?zero)/.test(color)) {
rule = color;
color = null;
}
if (color) {
this.fillColor(color);
}
return this.addContent(`f${this._windingRule(rule)}`);
},
stroke(color) {
if (color) {
this.strokeColor(color);
}
return this.addContent('S');
},
fillAndStroke(fillColor, strokeColor, rule) {
if (strokeColor == null) {
strokeColor = fillColor;
}
const isFillRule = /(even-?odd)|(non-?zero)/;
if (isFillRule.test(fillColor)) {
rule = fillColor;
fillColor = null;
}
if (isFillRule.test(strokeColor)) {
rule = strokeColor;
strokeColor = fillColor;
}
if (fillColor) {
this.fillColor(fillColor);
this.strokeColor(strokeColor);
}
return this.addContent(`B${this._windingRule(rule)}`);
},
clip(rule) {
return this.addContent(`W${this._windingRule(rule)} n`);
},
transform(m11, m12, m21, m22, dx, dy) {
if (m11 === 1 && m12 === 0 && m21 === 0 && m22 === 1 && dx === 0 && dy === 0) {
return this;
}
const m = this._ctm;
const [m0, m1, m2, m3, m4, m5] = m;
m[0] = m0 * m11 + m2 * m12;
m[1] = m1 * m11 + m3 * m12;
m[2] = m0 * m21 + m2 * m22;
m[3] = m1 * m21 + m3 * m22;
m[4] = m0 * dx + m2 * dy + m4;
m[5] = m1 * dx + m3 * dy + m5;
const values = [m11, m12, m21, m22, dx, dy].map(v => number$1(v)).join(' ');
return this.addContent(`${values} cm`);
},
translate(x, y) {
return this.transform(1, 0, 0, 1, x, y);
},
rotate(angle, options = {}) {
let y;
const rad = angle * Math.PI / 180;
const cos = Math.cos(rad);
const sin = Math.sin(rad);
let x = y = 0;
if (options.origin != null) {
[x, y] = options.origin;
const x1 = x * cos - y * sin;
const y1 = x * sin + y * cos;
x -= x1;
y -= y1;
}
return this.transform(cos, sin, -sin, cos, x, y);
},
scale(xFactor, yFactor, options = {}) {
let y;
if (yFactor == null) {
yFactor = xFactor;
}
if (typeof yFactor === 'object') {
options = yFactor;
yFactor = xFactor;
}
let x = y = 0;
if (options.origin != null) {
[x, y] = options.origin;
x -= xFactor * x;
y -= yFactor * y;
}
return this.transform(xFactor, 0, 0, yFactor, x, y);
}
};
const unsupported = path => {
throw new Error(`Cannot read '${path}': file paths are not supported outside of Node. ` + 'Pass a Uint8Array, ArrayBuffer or a data URL instead.');
};
const registeredFiles = new Map();
const getTimestamp = (value, name, defaultValue) => {
if (value === undefined) {
return defaultValue;
}
if (!(value instanceof Date) || Number.isNaN(value.getTime())) {
throw new TypeError(`Expected options.${name} to be a valid Date`);
}
return value.getTime();
};
function registerFile(path, data, options = {}) {
if (typeof path !== 'string') {
throw new TypeError(`Expected a string for path, got ${typeof path}`);
}
if (data === undefined) {
registeredFiles.delete(path);
return;
}
if (!(data instanceof Uint8Array)) {
throw new TypeError(`Expected a Uint8Array or undefined for data, got ${typeof data}`);
}
if (options === null || typeof options !== 'object') {
throw new TypeError(`Expected options to be an object`);
}
const registeredAt = Date.now();
registeredFiles.set(path, {
data,
birthtime: getTimestamp(options.birthtime, 'birthtime', registeredAt),
ctime: getTimestamp(options.ctime, 'ctime', registeredAt)
});
}
var fs = {
readFileSync(path) {
if (registeredFiles.has(path)) {
return registeredFiles.get(path).data;
}
return unsupported(path);
},
statSync(path) {
if (registeredFiles.has(path)) {
const {
birthtime,
ctime
} = registeredFiles.get(path);
return {
birthtime: new Date(birthtime),
ctime: new Date(ctime)
};
}
return unsupported(path);
}
};
const WIN_ANSI_MAP = {
402: 131,
8211: 150,
8212: 151,
8216: 145,
8217: 146,
8218: 130,
8220: 147,
8221: 148,
8222: 132,
8224: 134,
8225: 135,
8226: 149,
8230: 133,
8364: 128,
8240: 137,
8249: 139,
8250: 155,
710: 136,
8482: 153,
338: 140,
339: 156,
732: 152,
352: 138,
353: 154,
376: 159,
381: 142,
382: 158
};
const characters = `\
.notdef .notdef .notdef .notdef
.notdef .notdef .notdef .notdef
.notdef .notdef .notdef .notdef
.notdef .notdef .notdef .notdef
.notdef .notdef .notdef .notdef
.notdef .notdef .notdef .notdef
.notdef .notdef .notdef .notdef
.notdef .notdef .notdef .notdef
space exclam quotedbl numbersign
dollar percent ampersand quotesingle
parenleft parenright asterisk plus
comma hyphen period slash
zero one two three
four five six seven
eight nine colon semicolon
less equal greater question
at A B C
D E F G
H I J K
L M N O
P Q R S
T U V W
X Y Z bracketleft
backslash bracketright asciicircum underscore
grave a b c
d e f g
h i j k
l m n o
p q r s
t u v w
x y z braceleft
bar braceright asciitilde .notdef
Euro .notdef quotesinglbase florin
quotedblbase ellipsis dagger daggerdbl
circumflex perthousand Scaron guilsinglleft
OE .notdef Zcaron .notdef
.notdef quoteleft quoteright quotedblleft
quotedblright bullet endash emdash
tilde trademark scaron guilsinglright
oe .notdef zcaron ydieresis
space exclamdown cent sterling
currency yen brokenbar section
dieresis copyright ordfeminine guillemotleft
logicalnot hyphen registered macron
degree plusminus twosuperior threesuperior
acute mu paragraph periodcentered
cedilla onesuperior ordmasculine guillemotright
onequarter onehalf threequarters questiondown
Agrave Aacute Acircumflex Atilde
Adieresis Aring AE Ccedilla
Egrave Eacute Ecircumflex Edieresis
Igrave Iacute Icircumflex Idieresis
Eth Ntilde Ograve Oacute
Ocircumflex Otilde Odieresis multiply
Oslash Ugrave Uacute Ucircumflex
Udieresis Yacute Thorn germandbls
agrave aacute acircumflex atilde
adieresis aring ae ccedilla
egrave eacute ecircumflex edieresis
igrave iacute icircumflex idieresis
eth ntilde ograve oacute
ocircumflex otilde odieresis divide
oslash ugrave uacute ucircumflex
udieresis yacute thorn ydieresis\
`.split(/\s+/);
class AFMFont {
constructor(data) {
this.name = data.name;
this.bbox = data.bbox.slice();
this.ascender = data.ascender;
this.descender = data.descender;
this.xHeight = data.xHeight;
this.capHeight = data.capHeight;
this.lineGap = this.bbox[3] - this.bbox[1] - (this.ascender - this.descender);
const glyphNames = data.glyphNames.split(' ');
this.glyphWidths = Object.fromEntries(glyphNames.map((name, index) => [name, data.glyphWidths[index]]));
this.kernPairs = {};
for (let index = 0; index < data.kernPairs.length; index += 2) {
const amount = data.kernPairs[index];
let pairId = 0;
for (const delta of data.kernPairs[index + 1]) {
pairId += delta;
const left = Math.floor(pairId / glyphNames.length);
const right = pairId % glyphNames.length;
this.kernPairs[`${glyphNames[left]}\0${glyphNames[right]}`] = amount;
}
}
}
encodeText(text) {
const res = [];
for (let i = 0, len = text.length; i < len; i++) {
let char = text.charCodeAt(i);
char = WIN_ANSI_MAP[char] || char;
res.push(char.toString(16));
}
return res;
}
glyphsForString(string) {
const glyphs = [];
for (let i = 0, len = string.length; i < len; i++) {
const charCode = string.charCodeAt(i);
glyphs.push(this.characterToGlyph(charCode));
}
return glyphs;
}
characterToGlyph(character) {
return characters[WIN_ANSI_MAP[character] || character] || '.notdef';
}
widthOfGlyph(glyph) {
return this.glyphWidths[glyph] || 0;
}
getKernPair(left, right) {
return this.kernPairs[left + '\0' + right] || 0;
}
advancesForGlyphs(glyphs) {
const advances = [];
for (let index = 0; index < glyphs.length; index++) {
const left = glyphs[index];
const right = glyphs[index + 1];
advances.push(this.widthOfGlyph(left) + this.getKernPair(left, right));
}
return advances;
}
}
class PDFFont {
constructor() {}
encode() {
throw new Error('Must be implemented by subclasses');
}
widthOfString() {
throw new Error('Must be implemented by subclasses');
}
ref() {
return this.dictionary != null ? this.dictionary : this.dictionary = this.document.ref();
}
finalize() {
if (this.embedded || this.dictionary == null) {
return;
}
this.embed();
this.embedded = true;
}
embed() {
throw new Error('Must be implemented by subclasses');
}
lineHeight(size, includeGap = false) {
const gap = includeGap ? this.lineGap : 0;
return (this.ascender + gap - this.descender) / 1000 * size;
}
}
class StandardFont extends PDFFont {
constructor(document, fontData, id) {
super();
this.document = document;
this.name = fontData.name;
this.id = id;
this.font = new AFMFont(fontData);
({
ascender: this.ascender,
descender: this.descender,
bbox: this.bbox,
lineGap: this.lineGap,
xHeight: this.xHeight,
capHeight: this.capHeight
} = this.font);
}
embed() {
this.dictionary.data = {
Type: 'Font',
BaseFont: this.name,
Subtype: 'Type1',
Encoding: 'WinAnsiEncoding'
};
return this.dictionary.end();
}
encode(text) {
const encoded = this.font.encodeText(text);
const glyphs = this.font.glyphsForString(`${text}`);
const advances = this.font.advancesForGlyphs(glyphs);
const positions = [];
for (let i = 0; i < glyphs.length; i++) {
const glyph = glyphs[i];
positions.push({
xAdvance: advances[i],
yAdvance: 0,
xOffset: 0,
yOffset: 0,
advanceWidth: this.font.widthOfGlyph(glyph)
});
}
return [encoded, positions];
}
widthOfString(string, size) {
const glyphs = this.font.glyphsForString(`${string}`);
const advances = this.font.advancesForGlyphs(glyphs);
let width = 0;
for (let advance of advances) {
width += advance;
}
const scale = size / 1000;
return width * scale;
}
}
const toHex = function (num) {
return `0000${num.toString(16)}`.slice(-4);
};
class EmbeddedFont extends PDFFont {
constructor(document, font, id) {
super();
this.document = document;
this.font = font;
this.id = id;
this.subset = this.font.createSubset();
this.unicode = [[0]];
this.widths = [this.font.getGlyph(0).advanceWidth];
this.name = this.font.postscriptName;
this.scale = 1000 / this.font.unitsPerEm;
this.ascender = this.font.ascent * this.scale;
this.descender = this.font.descent * this.scale;
this.xHeight = this.font.xHeight * this.scale;
this.capHeight = this.font.capHeight * this.scale;
this.lineGap = this.font.lineGap * this.scale;
this.bbox = this.font.bbox;
if (document.options.fontLayoutCache !== false) {
this.layoutCache = Object.create(null);
}
}
layoutRun(text, features) {
const run = this.font.layout(text, features);
for (let i = 0; i < run.positions.length; i++) {
const position = run.positions[i];
for (let key in position) {
position[key] *= this.scale;
}
position.advanceWidth = run.glyphs[i].advanceWidth * this.scale;
}
return run;
}
layoutCached(text) {
if (!this.layoutCache) {
return this.layoutRun(text);
}
let cached;
if (cached = this.layoutCache[text]) {
return cached;
}
const run = this.layoutRun(text);
this.layoutCache[text] = run;
return run;
}
layout(text, features, onlyWidth) {
if (features) {
return this.layoutRun(text, features);
}
let glyphs = onlyWidth ? null : [];
let positions = onlyWidth ? null : [];
let advanceWidth = 0;
let last = 0;
let index = 0;
while (index <= text.length) {
var needle;
if (index === text.length && last < index || (needle = text.charAt(index), [' ', '\t'].includes(needle))) {
const run = this.layoutCached(text.slice(last, ++index));
if (!onlyWidth) {
glyphs = glyphs.concat(run.glyphs);
positions = positions.concat(run.positions);
}
advanceWidth += run.advanceWidth;
last = index;
} else {
index++;
}
}
return {
glyphs,
positions,
advanceWidth
};
}
encode(text, features) {
const {
glyphs,
positions
} = this.layout(text, features);
const res = [];
for (let i = 0; i < glyphs.length; i++) {
const glyph = glyphs[i];
const gid = this.subset.includeGlyph(glyph.id);
res.push(`0000${gid.toString(16)}`.slice(-4));
if (this.widths[gid] == null) {
this.widths[gid] = glyph.advanceWidth * this.scale;
}
if (this.unicode[gid] == null) {
this.unicode[gid] = glyph.codePoints;
}
}
return [res, positions];
}
widthOfString(string, size, features) {
const width = this.layout(string, features, true).advanceWidth;
const scale = size / 1000;
return width * scale;
}
embed() {
const isCFF = this.subset.cff != null;
const fontFile = this.document.ref();
if (isCFF) {
fontFile.data.Subtype = 'CIDFontType0C';
}
fontFile.end(this.subset.encode());
const familyClass = ((this.font['OS/2'] != null ? this.font['OS/2'].sFamilyClass : undefined) || 0) >> 8;
let flags = 0;
if (this.font.post.isFixedPitch) {
flags |= 1 << 0;
}
if (1 <= familyClass && familyClass <= 7) {
flags |= 1 << 1;
}
flags |= 1 << 2;
if (familyClass === 10) {
flags |= 1 << 3;
}
if (this.font.head.macStyle.italic) {
flags |= 1 << 6;
}
const tag = [1, 2, 3, 4, 5, 6].map(i => String.fromCharCode((this.id.charCodeAt(i) || 73) + 17)).join('');
const name = tag + '+' + this.font.postscriptName?.replaceAll(' ', '_');
const {
bbox
} = this.font;
const descriptor = this.document.ref({
Type: 'FontDescriptor',
FontName: name,
Flags: flags,
FontBBox: [bbox.minX * this.scale, bbox.minY * this.scale, bbox.maxX * this.scale, bbox.maxY * this.scale],
ItalicAngle: this.font.italicAngle,
Ascent: this.ascender,
Descent: this.descender,
CapHeight: (this.font.capHeight || this.font.ascent) * this.scale,
XHeight: (this.font.xHeight || 0) * this.scale,
StemV: 0
});
if (isCFF) {
descriptor.data.FontFile3 = fontFile;
} else {
descriptor.data.FontFile2 = fontFile;
}
if (this.document.subset && this.document.subset === 1) {
const maxCID = this.widths.length - 1;
const cidSetBuffer = new Uint8Array(Math.ceil((maxCID + 1) / 8));
for (let cid = 0; cid <= maxCID; cid++) {
if (this.widths[cid] != null) {
cidSetBuffer[Math.floor(cid / 8)] |= 0x80 >> cid % 8;
}
}
const CIDSetRef = this.document.ref();
CIDSetRef.write(cidSetBuffer);
CIDSetRef.end();
descriptor.data.CIDSet = CIDSetRef;
}
descriptor.end();
const descendantFontData = {
Type: 'Font',
Subtype: 'CIDFontType0',
BaseFont: name,
CIDSystemInfo: {
Registry: new String('Adobe'),
Ordering: new String('Identity'),
Supplement: 0
},
FontDescriptor: descriptor,
W: [0, this.widths]
};
if (!isCFF) {
descendantFontData.Subtype = 'CIDFontType2';
descendantFontData.CIDToGIDMap = 'Identity';
}
const descendantFont = this.document.ref(descendantFontData);
descendantFont.end();
this.dictionary.data = {
Type: 'Font',
Subtype: 'Type0',
BaseFont: name,
Encoding: 'Identity-H',
DescendantFonts: [descendantFont],
ToUnicode: this.toUnicodeCmap()
};
return this.dictionary.end();
}
toUnicodeCmap() {
const cmap = this.document.ref();
const entries = [];
for (let codePoints of this.unicode) {
const encoded = [];
for (let value of codePoints) {
if (value > 0xffff) {
value -= 0x10000;
encoded.push(toHex(value >>> 10 & 0x3ff | 0xd800));
value = 0xdc00 | value & 0x3ff;
}
encoded.push(toHex(value));
}
entries.push(`<${encoded.join(' ')}>`);
}
const chunkSize = 256;
const chunks = Math.ceil(entries.length / chunkSize);
const ranges = [];
for (let i = 0; i < chunks; i++) {
const start = i * chunkSize;
const end = Math.min((i + 1) * chunkSize, entries.length);
ranges.push(`<${toHex(start)}> <${toHex(end - 1)}> [${entries.slice(start, end).join(' ')}]`);
}
cmap.end(`\
/CIDInit /ProcSet findresource begin
12 dict begin
begincmap
/CIDSystemInfo <<
/Registry (Adobe)
/Ordering (UCS)
/Supplement 0
>> def
/CMapName /Adobe-Identity-UCS def
/CMapType 2 def
1 begincodespacerange
<0000><ffff>
endcodespacerange
${ranges.length} beginbfrange
${ranges.join('\n')}
endbfrange
endcmap
CMapName currentdict /CMap defineresource pop
end
end\
`);
return cmap;
}
}
const STANDARD_FONT_NAMES = ['Courier', 'Courier-Bold', 'Courier-BoldOblique', 'Courier-Oblique', 'Helvetica', 'Helvetica-Bold', 'Helvetica-BoldOblique', 'Helvetica-Oblique', 'Symbol', 'Times-Bold', 'Times-BoldItalic', 'Times-Italic', 'Times-Roman', 'ZapfDingbats'];
const STANDARD_FONT_NAME_SET = new Set(STANDARD_FONT_NAMES);
const validateFontData = (fontData, expectedName) => {
if (fontData == null || typeof fontData !== 'object' || !STANDARD_FONT_NAME_SET.has(fontData.name) || expectedName != null && fontData.name !== expectedName) {
throw new TypeError('Invalid standard font data.');
}
};
const standardFonts = new Map();
const isStandardFont = name => STANDARD_FONT_NAME_SET.has(name);
const registerStdFonts = (...fontData) => {
for (const data of fontData) {
validateFontData(data);
standardFonts.set(data.name, data);
}
};
const getStandardFont = name => {
if (!STANDARD_FONT_NAME_SET.has(name)) {
return null;
}
const font = standardFonts.get(name);
if (font == null) {
throw new Error(`Standard font "${name}" is not registered. ` + 'Call registerStdFonts() before using it.');
}
if (typeof font !== 'function') {
return font;
}
const data = font();
validateFontData(data, name);
standardFonts.set(name, data);
return data;
};
class PDFFontFactory {
static open(document, src, family, id) {
let font;
if (typeof src === 'string') {
if (isStandardFont(src)) {
return new StandardFont(document, getStandardFont(src), id);
}
src = fs.readFileSync(src);
}
if (src instanceof Uint8Array) {
font = fontkit.create(src, family);
} else if (src instanceof ArrayBuffer) {
font = fontkit.create(new Uint8Array(src), family);
}
if (font == null) {
throw new Error('Not a supported font format or standard PDF font.');
}
return new EmbeddedFont(document, font, id);
}
}
const isEqualFont = (font1, font2) => {
if (font1.font._tables?.head?.checkSumAdjustment !== font2.font._tables?.head?.checkSumAdjustment) {
return false;
}
if (JSON.stringify(font1.font._tables?.name?.records) !== JSON.stringify(font2.font._tables?.name?.records)) {
return false;
}
return true;
};
var FontsMixin = {
initFonts(defaultFont = 'Helvetica', defaultFontFamily = null, defaultFontSize = 12) {
this._fontFamilies = {};
this._fontCount = 0;
this._fontSource = defaultFont;
this._fontFamily = defaultFontFamily;
this._fontSize = defaultFontSize;
this._font = null;
this._remSize = defaultFontSize;
this._registeredFonts = {};
if (defaultFont) {
this.font(defaultFont, defaultFontFamily);
}
},
font(src, family, size) {
let cacheKey, font;
if (typeof family === 'number') {
size = family;
family = null;
}
if (typeof src === 'string' && this._registeredFonts[src]) {
cacheKey = src;
({
src,
family
} = this._registeredFonts[src]);
} else {
cacheKey = family || src;
if (typeof cacheKey !== 'string') {
cacheKey = null;
}
}
this._fontSource = src;
this._fontFamily = family;
if (size != null) {
this.fontSize(size);
}
if (font = this._fontFamilies[cacheKey]) {
this._font = font;
return this;
}
const id = `F${++this._fontCount}`;
this._font = PDFFontFactory.open(this, src, family, id);
if ((font = this._fontFamilies[this._font.name]) && isEqualFont(this._font, font)) {
this._font = font;
return this;
}
if (cacheKey) {
this._fontFamilies[cacheKey] = this._font;
}
if (this._font.name && !this._fontFamilies[this._font.name]) {
this._fontFamilies[this._font.name] = this._font;
}
if (!cacheKey && (!this._font.name || this._fontFamilies[this._font.name] !== this._font)) {
this._fontFamilies[this._font.id] = this._font;
}
return this;
},
fontSize(_fontSize) {
this._fontSize = this.sizeToPoint(_fontSize);
return this;
},
currentLineHeight(includeGap) {
return this._font.lineHeight(this._fontSize, includeGap);
},
registerFont(name, src, family) {
this._registeredFonts[name] = {
src,
family
};
return this;
},
sizeToPoint(size, defaultValue = 0, page = this.page, percentageWidth = undefined) {
if (!percentageWidth) percentageWidth = this._fontSize;
if (typeof defaultValue !== 'number') defaultValue = this.sizeToPoint(defaultValue);
if (size === undefined) return defaultValue;
if (typeof size === 'number') return size;
if (typeof size === 'boolean') return Number(size);
const match = String(size).match(/((\d+)?(\.\d+)?)(em|in|px|cm|mm|pc|ex|ch|rem|vw|vh|vmin|vmax|%|pt)?/);
if (!match) throw new Error(`Unsupported size '${size}'`);
let multiplier;
switch (match[4]) {
case 'em':
multiplier = this._fontSize;
break;
case 'in':
multiplier = IN_TO_PT;
break;
case 'px':
multiplier = PX_TO_IN * IN_TO_PT;
break;
case 'cm':
multiplier = CM_TO_IN * IN_TO_PT;
break;
case 'mm':
multiplier = MM_TO_CM * CM_TO_IN * IN_TO_PT;
break;
case 'pc':
multiplier = PC_TO_PT;
break;
case 'ex':
multiplier = this.currentLineHeight();
break;
case 'ch':
multiplier = this.widthOfString('0');
break;
case 'rem':
multiplier = this._remSize;
break;
case 'vw':
multiplier = page.width / 100;
break;
case 'vh':
multiplier = page.height / 100;
break;
case 'vmin':
multiplier = Math.min(page.width, page.height) / 100;
break;
case 'vmax':
multiplier = Math.max(page.width, page.height) / 100;
break;
case '%':
multiplier = percentageWidth / 100;
break;
case 'pt':
default:
multiplier = 1;
}
return multiplier * Number(match[1]);
}
};
const SOFT_HYPHEN = '\u00AD';
const HYPHEN = '-';
class LineWrapper extends EventEmitter {
constructor(document, options) {
super();
this.document = document;
this.horizontalScaling = options.horizontalScaling || 100;
this.indent = (options.indent || 0) * this.horizontalScaling / 100;
this.indentAllLines = options.indentAllLines || false;
this.characterSpacing = (options.characterSpacing || 0) * this.horizontalScaling / 100;
this.wordSpacing = (options.wordSpacing === 0) * this.horizontalScaling / 100;
this.columns = options.columns || 1;
this.columnGap = (options.columnGap != null ? options.columnGap : 18) * this.horizontalScaling / 100;
this.lineWidth = (options.width * this.horizontalScaling / 100 - this.columnGap * (this.columns - 1)) / this.columns;
this.spaceLeft = this.lineWidth;
this.startX = this.document.x;
this.startY = this.document.y;
this.column = 1;
this.ellipsis = options.ellipsis;
this.continuedX = 0;
this.indentApplied = false;
this.features = options.features;
if (options.height != null) {
this.height = options.height;
this.maxY = PDFNumber(this.startY + options.height);
} else {
this.maxY = PDFNumber(this.document.page.maxY());
}
this.on('firstLine', options => {
const continuation = this.continuedX;
const indent = continuation || this.indent;
if (continuation || !this.indentApplied) {
this.document.x += indent;
this.lineWidth -= indent;
this.indentApplied = true;
}
if (options.indentAllLines) {
if (continuation) {
this.once('line', () => {
this.document.x -= continuation;
this.lineWidth += continuation;
});
}
return;
}
this.once('line', () => {
this.document.x -= indent;
this.lineWidth += indent;
this.indentApplied = false;
if (options.continued && !this.continuedX) {
this.continuedX = this.indent;
}
if (!options.continued) {
this.continuedX = 0;
}
});
});
this.on('lastLine', options => {
const {
align
} = options;
if (align === 'justify') {
options.align = 'left';
}
this.lastLine = true;
this.once('line', () => {
this.document.y += options.paragraphGap || 0;
options.align = align;
return this.lastLine = false;
});
});
}
wordWidth(word) {
return PDFNumber(this.document.widthOfString(word, this) + this.characterSpacing + this.wordSpacing);
}
canFit(word, w) {
if (word[word.length - 1] != SOFT_HYPHEN) {
return w <= this.spaceLeft;
}
return w + this.wordWidth(HYPHEN) <= this.spaceLeft;
}
eachWord(text, fn) {
let bk;
const breaker = new LineBreaker(text);
let last = null;
const wordWidths = Object.create(null);
while (bk = breaker.nextBreak()) {
var shouldContinue;
let word = text.slice((last != null ? last.position : undefined) || 0, bk.position);
let w = wordWidths[word] != null ? wordWidths[word] : wordWidths[word] = this.wordWidth(word);
if (w > this.lineWidth + this.continuedX) {
let lbk = last;
const fbk = {};
while (word.length) {
var l, mightGrow;
if (w > this.spaceLeft) {
l = Math.ceil(this.spaceLeft / (w / word.length));
w = this.wordWidth(word.slice(0, l));
mightGrow = w <= this.spaceLeft && l < word.length;
} else {
l = word.length;
}
let mustShrink = w > this.spaceLeft && l > 0;
while (mustShrink || mightGrow) {
if (mustShrink) {
w = this.wordWidth(word.slice(0, --l));
mustShrink = w > this.spaceLeft && l > 0;
} else {
w = this.wordWidth(word.slice(0, ++l));
mustShrink = w > this.spaceLeft && l > 0;
mightGrow = w <= this.spaceLeft && l < word.length;
}
}
if (l === 0 && this.spaceLeft === this.lineWidth) {
l = 1;
}
fbk.required = bk.required || l < word.length;
shouldContinue = fn(word.slice(0, l), w, fbk, lbk);
lbk = {
required: false
};
word = word.slice(l);
w = this.wordWidth(word);
if (shouldContinue === false) {
break;
}
}
} else {
shouldContinue = fn(word, w, bk, last);
}
if (shouldContinue === false) {
break;
}
last = bk;
}
}
wrap(text, options) {
const {
document
} = this;
this.horizontalScaling = options.horizontalScaling || 100;
if (options.indent != null) {
this.indent = options.indent * this.horizontalScaling / 100;
}
if (options.characterSpacing != null) {
this.characterSpacing = options.characterSpacing * this.horizontalScaling / 100;
}
if (options.wordSpacing != null) {
this.wordSpacing = options.wordSpacing * this.horizontalScaling / 100;
}
if (options.ellipsis != null) {
this.ellipsis = options.ellipsis;
}
const nextY = document.y + document.currentLineHeight(true);
if (document.y > this.maxY || nextY > this.maxY) {
this.nextSection();
}
let buffer = '';
let textWidth = 0;
let wc = 0;
let lc = 0;
let continueY = document.y;
const emitLine = () => {
options.textWidth = textWidth + this.wordSpacing * (wc - 1);
options.wordCount = wc;
options.lineWidth = this.lineWidth;
continueY = document.y;
this.emit('line', buffer, options, this);
return lc++;
};
this.emit('sectionStart', options, this);
this.eachWord(text, (word, w, bk, last) => {
if (last == null || last.required) {
this.emit('firstLine', options, this);
this.spaceLeft = this.lineWidth;
}
if (this.canFit(word, w)) {
buffer += word;
textWidth += w;
wc++;
}
if (bk.required || !this.canFit(word, w)) {
const lh = document.currentLineHeight(true);
if (this.height != null && this.ellipsis && PDFNumber(document.y + lh * 2) > this.maxY && this.column >= this.columns) {
if (this.ellipsis === true) {
this.ellipsis = '…';
}
buffer = buffer.replace(/\s+$/, '');
textWidth = this.wordWidth(buffer + this.ellipsis);
while (buffer && textWidth > this.lineWidth) {
buffer = buffer.slice(0, -1).replace(/\s+$/, '');
textWidth = this.wordWidth(buffer + this.ellipsis);
}
if (textWidth <= this.lineWidth) {
buffer = buffer + this.ellipsis;
}
textWidth = this.wordWidth(buffer);
}
if (bk.required) {
if (w > this.spaceLeft) {
emitLine();
buffer = word;
textWidth = w;
wc = 1;
}
this.emit('lastLine', options, this);
}
if (buffer[buffer.length - 1] == SOFT_HYPHEN) {
buffer = buffer.slice(0, -1) + HYPHEN;
this.spaceLeft -= this.wordWidth(HYPHEN);
}
emitLine();
if (PDFNumber(document.y + lh) > this.maxY) {
this.emit('sectionEnd', options, this);
const shouldContinue = this.nextSection();
if (!shouldContinue) {
wc = 0;
buffer = '';
return false;
}
this.emit('sectionStart', options, this);
}
if (bk.required) {
this.spaceLeft = this.lineWidth;
buffer = '';
textWidth = 0;
return wc = 0;
} else {
this.spaceLeft = this.lineWidth - w;
buffer = word;
textWidth = w;
return wc = 1;
}
} else {
return this.spaceLeft -= w;
}
});
if (wc > 0) {
this.emit('lastLine', options, this);
emitLine();
}
this.emit('sectionEnd', options, this);
if (options.continued === true) {
if (lc > 1) {
this.continuedX = 0;
}
this.continuedX += options.textWidth || 0;
document.y = continueY;
} else {
document.x = this.startX;
}
}
nextSection(options) {
if (++this.column > this.columns) {
if (this.height != null) {
return false;
}
this.document.continueOnNewPage();
this.column = 1;
this.startY = this.document.page.margins.top;
this.maxY = this.document.page.maxY();
if (this.indentAllLines) {
if (this.indentApplied) {
this.document.x += this.continuedX || this.indent;
}
} else {
this.document.x = this.startX;
}
if (this.document._fillColor) {
this.document.fillColor(...this.document._fillColor);
}
this.emit('pageBreak', options, this);
} else {
this.document.x += this.lineWidth + this.columnGap;
this.document.y = this.startY;
this.emit('columnBreak', options, this);
}
return true;
}
}
const {
number
} = PDFObject;
function formatListLabel(n, listType) {
if (listType === 'numbered') {
return `${n}.`;
}
var letter = String.fromCharCode((n - 1) % 26 + 65);
var times = Math.floor((n - 1) / 26 + 1);
var text = Array(times + 1).join(letter);
return `${text}.`;
}
var TextMixin = {
initText() {
this._line = this._line.bind(this);
this.x = 0;
this.y = 0;
this._lineGap = 0;
},
lineGap(_lineGap) {
this._lineGap = _lineGap;
return this;
},
moveDown(lines) {
if (lines == null) {
lines = 1;
}
this.y += this.currentLineHeight(true) * lines + this._lineGap;
return this;
},
moveUp(lines) {
if (lines == null) {
lines = 1;
}
this.y -= this.currentLineHeight(true) * lines + this._lineGap;
return this;
},
_text(text, x, y, options, lineCallback) {
options = this._initOptions(x, y, options);
text = text == null ? '' : `${text}`;
if (options.wordSpacing) {
text = text.replace(/\s{2,}/g, ' ');
}
const addStructure = () => {
if (options.structParent) {
options.structParent.add(this.struct(options.structType || 'P', [this.markStructureContent(options.structType || 'P')]));
}
};
if (options.rotation !== 0) {
this.save();
this.rotate(-options.rotation, {
origin: [this.x, this.y]
});
}
if (options.width) {
let wrapper = this._wrapper;
if (!wrapper) {
wrapper = new LineWrapper(this, options);
wrapper.on('line', lineCallback);
wrapper.on('firstLine', addStructure);
}
this._wrapper = options.continued ? wrapper : null;
this._textOptions = options.continued ? options : null;
wrapper.wrap(text, options);
} else {
for (let line of text.split('\n')) {
addStructure();
lineCallback(line, options);
}
}
if (options.rotation !== 0) this.restore();
return this;
},
text(text, x, y, options) {
return this._text(text, x, y, options, this._line);
},
widthOfString(string, options = {}) {
const horizontalScaling = options.horizontalScaling || 100;
return (this._font.widthOfString(string, this._fontSize, options.features) + (options.characterSpacing || 0) * (string.length - 1)) * horizontalScaling / 100;
},
boundsOfString(string, x, y, options) {
options = this._initOptions(x, y, options);
({
x,
y
} = this);
const lineGap = options.lineGap ?? this._lineGap ?? 0;
const lineHeight = this.currentLineHeight(true) + lineGap;
let contentWidth = 0;
string = String(string ?? '');
if (options.wordSpacing) {
string = string.replace(/\s{2,}/g, ' ');
}
if (options.width) {
let wrapper = new LineWrapper(this, options);
wrapper.on('line', (text, options) => {
this.y += lineHeight;
text = text.replace(/\n/g, '');
if (text.length) {
let wordSpacing = options.wordSpacing ?? 0;
const characterSpacing = options.characterSpacing ?? 0;
if (options.width && options.align === 'justify') {
const words = text.trim().split(/\s+/);
const textWidth = this.widthOfString(text.replace(/\s+/g, ''), options);
const spaceWidth = this.widthOfString(' ') + characterSpacing;
wordSpacing = Math.max(0, (options.lineWidth - textWidth) / Math.max(1, words.length - 1) - spaceWidth);
}
contentWidth = Math.max(contentWidth, options.textWidth + wordSpacing * (options.wordCount - 1) + characterSpacing * (text.length - 1));
}
});
wrapper.wrap(string, options);
} else {
for (let line of string.split('\n')) {
const lineWidth = this.widthOfString(line, options);
this.y += lineHeight;
contentWidth = Math.max(contentWidth, lineWidth);
}
}
let contentHeight = this.y - y;
if (options.height) contentHeight = Math.min(contentHeight, options.height);
this.x = x;
this.y = y;
if (options.rotation === 0) {
return {
x,
y,
width: contentWidth,
height: contentHeight
};
} else if (options.rotation === 90) {
return {
x: x,
y: y - contentWidth,
width: contentHeight,
height: contentWidth
};
} else if (options.rotation === 180) {
return {
x: x - contentWidth,
y: y - contentHeight,
width: contentWidth,
height: contentHeight
};
} else if (options.rotation === 270) {
return {
x: x - contentHeight,
y: y,
width: contentHeight,
height: contentWidth
};
}
const cos = cosine(options.rotation);
const sin = sine(options.rotation);
const x1 = x;
const y1 = y;
const x2 = x + contentWidth * cos;
const y2 = y - contentWidth * sin;
const x3 = x + contentWidth * cos + contentHeight * sin;
const y3 = y - contentWidth * sin + contentHeight * cos;
const x4 = x + contentHeight * sin;
const y4 = y + contentHeight * cos;
const xMin = Math.min(x1, x2, x3, x4);
const xMax = Math.max(x1, x2, x3, x4);
const yMin = Math.min(y1, y2, y3, y4);
const yMax = Math.max(y1, y2, y3, y4);
return {
x: xMin,
y: yMin,
width: xMax - xMin,
height: yMax - yMin
};
},
heightOfString(text, options) {
const {
x,
y
} = this;
options = this._initOptions(options);
options.height = Infinity;
const lineGap = options.lineGap || this._lineGap || 0;
this._text(text, this.x, this.y, options, () => {
this.y += this.currentLineHeight(true) + lineGap;
});
const height = this.y - y;
this.x = x;
this.y = y;
return height;
},
list(list, x, y, options) {
options = this._initOptions(x, y, options);
const listType = options.listType || 'bullet';
const unit = Math.round(this._font.ascender / 1000 * this._fontSize);
const midLine = unit / 2;
const r = options.bulletRadius || unit / 3;
const indent = options.textIndent || (listType === 'bullet' ? r * 5 : unit * 2);
const itemIndent = options.bulletIndent || (listType === 'bullet' ? r * 8 : unit * 2);
let level = 1;
const items = [];
const levels = [];
const numbers = [];
var flatten = function (list) {
let n = 1;
for (let i = 0; i < list.length; i++) {
const item = list[i];
if (Array.isArray(item)) {
level++;
flatten(item);
level--;
} else {
items.push(item);
levels.push(level);
if (listType !== 'bullet') {
numbers.push(n++);
}
}
}
};
flatten(list);
const drawListItem = function (listItem, i) {
const wrapper = new LineWrapper(this, options);
wrapper.on('line', this._line);
level = 1;
wrapper.once('firstLine', () => {
let item, itemType, labelType, bodyType;
if (options.structParent) {
if (options.structTypes) {
[itemType, labelType, bodyType] = options.structTypes;
} else {
[itemType, labelType, bodyType] = ['LI', 'Lbl', 'LBody'];
}
}
if (itemType) {
item = this.struct(itemType);
options.structParent.add(item);
} else if (options.structParent) {
item = options.structParent;
}
let l;
if ((l = levels[i++]) !== level) {
const diff = itemIndent * (l - level);
this.x += diff;
wrapper.lineWidth -= diff;
level = l;
}
if (item && (labelType || bodyType)) {
item.add(this.struct(labelType || bodyType, [this.markStructureContent(labelType || bodyType)]));
}
switch (listType) {
case 'bullet':
this.circle(this.x - indent + r, this.y + midLine, r);
this.fill();
break;
case 'numbered':
case 'lettered':
var text = formatListLabel(numbers[i - 1], listType);
this._fragment(text, this.x - indent, this.y, options);
break;
}
if (item && labelType && bodyType) {
item.add(this.struct(bodyType, [this.markStructureContent(bodyType)]));
}
if (item && item !== options.structParent) {
item.end();
}
});
wrapper.on('sectionStart', () => {
const pos = indent + itemIndent * (level - 1);
this.x += pos;
wrapper.lineWidth -= pos;
});
wrapper.on('sectionEnd', () => {
const pos = indent + itemIndent * (level - 1);
this.x -= pos;
wrapper.lineWidth += pos;
});
wrapper.wrap(listItem, options);
};
for (let i = 0; i < items.length; i++) {
drawListItem.call(this, items[i], i);
}
return this;
},
_initOptions(x = {}, y, options = {}) {
if (x && typeof x === 'object') {
options = x;
x = null;
}
const result = Object.assign({}, options);
if (this._textOptions) {
for (let key in this._textOptions) {
const val = this._textOptions[key];
if (key !== 'continued') {
if (result[key] === undefined) {
result[key] = val;
}
}
}
}
if (x != null) {
this.x = x;
}
if (y != null) {
this.y = y;
}
if (result.lineBreak !== false) {
if (result.width == null) {
result.width = this.page.width - this.x - this.page.margins.right;
}
result.width = Math.max(result.width, 0);
}
if (!result.columns) {
result.columns = 0;
}
if (result.columnGap == null) {
result.columnGap = 18;
}
result.rotation = Number(result.rotation ?? 0) % 360;
if (result.rotation < 0) result.rotation += 360;
return result;
},
_line(text, options = {}, wrapper) {
this._fragment(text, this.x, this.y, options);
if (wrapper) {
const lineGap = options.lineGap || this._lineGap || 0;
this.y += this.currentLineHeight(true) + lineGap;
} else {
this.x += this.widthOfString(text, options);
}
},
_fragment(text, x, y, options) {
let dy, encoded, i, positions, textWidth, words;
text = `${text}`.replace(/\n/g, '');
if (text.length === 0) {
return;
}
const align = options.align || 'left';
let wordSpacing = options.wordSpacing || 0;
const characterSpacing = options.characterSpacing || 0;
const horizontalScaling = options.horizontalScaling || 100;
if (options.width) {
switch (align) {
case 'right':
textWidth = this.widthOfString(text.replace(/\s+$/, ''), options);
x += options.lineWidth - textWidth;
break;
case 'center':
x += options.lineWidth / 2 - options.textWidth / 2;
break;
case 'justify':
words = text.trim().split(/\s+/);
textWidth = this.widthOfString(text.replace(/\s+/g, ''), options);
var spaceWidth = this.widthOfString(' ') + characterSpacing;
wordSpacing = Math.max(0, (options.lineWidth - textWidth) / Math.max(1, words.length - 1) - spaceWidth);
break;
}
}
if (typeof options.baseline === 'number') {
dy = -options.baseline;
} else {
switch (options.baseline) {
case 'svg-middle':
dy = 0.5 * this._font.xHeight;
break;
case 'middle':
case 'svg-central':
dy = 0.5 * (this._font.descender + this._font.ascender);
break;
case 'bottom':
case 'ideographic':
dy = this._font.descender;
break;
case 'alphabetic':
dy = 0;
break;
case 'mathematical':
dy = 0.5 * this._font.ascender;
break;
case 'hanging':
dy = 0.8 * this._font.ascender;
break;
case 'top':
dy = this._font.ascender;
break;
default:
dy = this._font.ascender;
}
dy = dy / 1000 * this._fontSize;
}
const renderedWidth = options.textWidth + wordSpacing * (options.wordCount - 1) + characterSpacing * (text.length - 1);
if (options.link != null) {
const linkOptions = {};
if (this._currentStructureElement && this._currentStructureElement.dictionary.data.S === 'Link') {
linkOptions.structParent = this._currentStructureElement;
}
this.link(x, y, renderedWidth, this.currentLineHeight(), options.link, linkOptions);
}
if (options.goTo != null) {
this.goTo(x, y, renderedWidth, this.currentLineHeight(), options.goTo);
}
if (options.destination != null) {
this.addNamedDestination(options.destination, 'XYZ', x, y, null);
}
if (options.underline) {
this.save();
if (!options.stroke) {
this.strokeColor(...(this._fillColor || []));
}
const lineWidth = this._fontSize < 10 ? 0.5 : Math.floor(this._fontSize / 10);
this.lineWidth(lineWidth);
let lineY = y + this.currentLineHeight() - lineWidth;
this.moveTo(x, lineY);
this.lineTo(x + renderedWidth, lineY);
this.stroke();
this.restore();
}
if (options.strike) {
this.save();
if (!options.stroke) {
this.strokeColor(...(this._fillColor || []));
}
const lineWidth = this._fontSize < 10 ? 0.5 : Math.floor(this._fontSize / 10);
this.lineWidth(lineWidth);
let lineY = y + this.currentLineHeight() / 2;
this.moveTo(x, lineY);
this.lineTo(x + renderedWidth, lineY);
this.stroke();
this.restore();
}
this.save();
if (options.oblique) {
let skew;
if (typeof options.oblique === 'number') {
skew = -Math.tan(options.oblique * Math.PI / 180);
} else {
skew = -0.25;
}
this.transform(1, 0, 0, 1, x, y);
this.transform(1, 0, skew, 1, -skew * dy, 0);
this.transform(1, 0, 0, 1, -x, -y);
}
this.transform(1, 0, 0, -1, 0, this.page.height);
y = this.page.height - y - dy;
if (this.page.fonts[this._font.id] == null) {
this.page.fonts[this._font.id] = this._font.ref();
}
this.addContent('BT');
this.addContent(`1 0 0 1 ${number(x)} ${number(y)} Tm`);
this.addContent(`/${this._font.id} ${number(this._fontSize)} Tf`);
const mode = options.fill && options.stroke ? 2 : options.stroke ? 1 : 0;
if (mode) {
this.addContent(`${mode} Tr`);
}
if (characterSpacing) {
this.addContent(`${number(characterSpacing)} Tc`);
}
if (horizontalScaling !== 100) {
this.addContent(`${horizontalScaling} Tz`);
}
if (wordSpacing) {
words = text.trim().split(/\s+/);
wordSpacing += this.widthOfString(' ') + characterSpacing;
wordSpacing *= 1000 / this._fontSize;
encoded = [];
positions = [];
for (let word of words) {
const [encodedWord, positionsWord] = this._font.encode(word, options.features);
encoded = encoded.concat(encodedWord);
positions = positions.concat(positionsWord);
const space = {};
const object = positions[positions.length - 1];
for (let key in object) {
const val = object[key];
space[key] = val;
}
space.xAdvance += wordSpacing;
positions[positions.length - 1] = space;
}
} else {
[encoded, positions] = this._font.encode(text, options.features);
}
const scale = this._fontSize / 1000;
const commands = [];
let last = 0;
let hadOffset = false;
const addSegment = cur => {
if (last < cur) {
const hex = encoded.slice(last, cur).join('');
const advance = positions[cur - 1].xAdvance - positions[cur - 1].advanceWidth;
commands.push(`<${hex}> ${number(-advance)}`);
}
last = cur;
};
const flush = i => {
addSegment(i);
if (commands.length > 0) {
this.addContent(`[${commands.join(' ')}] TJ`);
commands.length = 0;
}
};
for (i = 0; i < positions.length; i++) {
const pos = positions[i];
if (pos.xOffset || pos.yOffset) {
flush(i);
this.addContent(`1 0 0 1 ${number(x + pos.xOffset * scale)} ${number(y + pos.yOffset * scale)} Tm`);
flush(i + 1);
hadOffset = true;
} else {
if (hadOffset) {
this.addContent(`1 0 0 1 ${number(x)} ${number(y)} Tm`);
hadOffset = false;
}
if (pos.xAdvance - pos.advanceWidth !== 0) {
addSegment(i + 1);
}
}
x += pos.xAdvance * scale;
}
flush(i);
this.addContent('ET');
this.restore();
}
};
const parseExifOrientation = data => {
if (!data || data.length < 20) return null;
let pos = 2;
while (pos < data.length - 4) {
while (pos < data.length && data[pos] !== 0xff) pos++;
if (pos >= data.length - 4) return null;
const marker = readUInt16BE(data, pos);
pos += 2;
if (marker === 0xffda) return null;
if (marker >= 0xffd0 && marker <= 0xffd9 || marker === 0xff01) continue;
if (pos + 2 > data.length) return null;
const segmentLength = readUInt16BE(data, pos);
if (marker === 0xffe1 && pos + 8 <= data.length) {
const exifHeader = toBinaryString(data.subarray(pos + 2, pos + 8));
if (exifHeader === 'Exif\x00\x00') {
const tiffStart = pos + 8;
if (tiffStart + 8 > data.length) return null;
const byteOrder = toBinaryString(data.subarray(tiffStart, tiffStart + 2));
const isLittleEndian = byteOrder === 'II';
if (!isLittleEndian && byteOrder !== 'MM') return null;
const read16 = isLittleEndian ? o => readUInt16LE(data, o) : o => readUInt16BE(data, o);
const read32 = isLittleEndian ? o => readUInt32LE(data, o) : o => readUInt32BE(data, o);
if (read16(tiffStart + 2) !== 42) return null;
const ifdPos = tiffStart + read32(tiffStart + 4);
if (ifdPos + 2 > data.length) return null;
const entryCount = read16(ifdPos);
for (let i = 0; i < entryCount; i++) {
const entryPos = ifdPos + 2 + i * 12;
if (entryPos + 12 > data.length) return null;
if (read16(entryPos) === 0x0112) {
const value = read16(entryPos + 8);
return value >= 1 && value <= 8 ? value : null;
}
}
return null;
}
}
pos += segmentLength;
}
return null;
};
const MARKERS = [0xffc0, 0xffc1, 0xffc2, 0xffc3, 0xffc5, 0xffc6, 0xffc7, 0xffc8, 0xffc9, 0xffca, 0xffcb, 0xffcc, 0xffcd, 0xffce, 0xffcf];
const COLOR_SPACE_MAP = {
1: 'DeviceGray',
3: 'DeviceRGB',
4: 'DeviceCMYK'
};
class JPEG {
constructor(data, label) {
let marker;
this.data = data;
this.label = label;
if (readUInt16BE(this.data, 0) !== 0xffd8) {
throw 'SOI not found in JPEG';
}
this.orientation = parseExifOrientation(this.data) || 1;
let pos = 2;
while (pos < this.data.length) {
while (pos < this.data.length && this.data[pos] !== 0xff) pos++;
if (pos >= this.data.length) break;
marker = readUInt16BE(this.data, pos);
pos += 2;
if (MARKERS.includes(marker)) {
break;
}
pos += readUInt16BE(this.data, pos);
}
if (!MARKERS.includes(marker)) {
throw 'Invalid JPEG.';
}
pos += 2;
this.bits = this.data[pos++];
this.height = readUInt16BE(this.data, pos);
pos += 2;
this.width = readUInt16BE(this.data, pos);
pos += 2;
const channels = this.data[pos];
this.colorSpace = COLOR_SPACE_MAP[channels];
this.obj = null;
}
embed(document) {
if (this.obj) {
return;
}
this.obj = document.ref({
Type: 'XObject',
Subtype: 'Image',
BitsPerComponent: this.bits,
Width: this.width,
Height: this.height,
ColorSpace: this.colorSpace,
Filter: 'DCTDecode'
});
if (this.colorSpace === 'DeviceCMYK') {
this.obj.data['Decode'] = [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0];
}
this.obj.end(this.data);
return this.data = null;
}
}
class PNGImage {
constructor(data, label) {
this.label = label;
this.image = new PNG(data);
this.width = this.image.width;
this.height = this.image.height;
this.imgData = this.image.imgData;
this.obj = null;
}
embed(document) {
this.document = document;
if (this.obj) {
return;
}
const {
image,
height,
width
} = this;
const hasAlphaChannel = image.hasAlphaChannel;
const isInterlaced = image.interlaceMethod === 1;
const obj = this.obj = document.ref({
Type: 'XObject',
Subtype: 'Image',
BitsPerComponent: hasAlphaChannel ? 8 : image.bits,
Width: width,
Height: height,
Filter: 'FlateDecode'
});
if (!hasAlphaChannel) {
const params = document.ref({
Predictor: isInterlaced ? 1 : 15,
Colors: image.colors,
BitsPerComponent: image.bits,
Columns: width
});
obj.data['DecodeParms'] = params;
params.end();
}
if (image.palette.length === 0) {
obj.data['ColorSpace'] = image.colorSpace;
} else {
const palette = document.ref();
palette.end(new Uint8Array(image.palette));
obj.data['ColorSpace'] = ['Indexed', 'DeviceRGB', image.palette.length / 3 - 1, palette];
}
if (image.transparency.grayscale != null) {
const val = image.transparency.grayscale;
obj.data['Mask'] = [val, val];
} else if (image.transparency.rgb) {
const {
rgb
} = image.transparency;
const mask = [];
for (let x of rgb) {
mask.push(x, x);
}
obj.data['Mask'] = mask;
} else if (image.transparency.indexed) {
return this.loadIndexedAlphaChannel();
} else if (hasAlphaChannel) {
return this.splitAlphaChannel();
}
if (isInterlaced && true) {
return this.decodeData();
}
this.finalize();
}
finalize() {
if (this.alphaChannel) {
const sMask = this.document.ref({
Type: 'XObject',
Subtype: 'Image',
Height: this.height,
Width: this.width,
BitsPerComponent: 8,
Filter: 'FlateDecode',
ColorSpace: 'DeviceGray',
Decode: [0, 1]
});
sMask.end(this.alphaChannel);
this.obj.data['SMask'] = sMask;
}
this.obj.end(this.imgData);
this.image = null;
return this.imgData = null;
}
splitAlphaChannel() {
return this.image.decodePixels(pixels => {
let a, p;
const colorCount = this.image.colors;
const pixelCount = this.width * this.height;
const imgData = new Uint8Array(pixelCount * colorCount);
const alphaChannel = new Uint8Array(pixelCount);
let i = p = a = 0;
const len = pixels.length;
const skipByteCount = this.image.bits === 16 ? 1 : 0;
while (i < len) {
for (let colorIndex = 0; colorIndex < colorCount; colorIndex++) {
imgData[p++] = pixels[i++];
i += skipByteCount;
}
alphaChannel[a++] = pixels[i++];
i += skipByteCount;
}
this.imgData = zlib.deflateSync(imgData);
this.alphaChannel = zlib.deflateSync(alphaChannel);
return this.finalize();
});
}
loadIndexedAlphaChannel() {
const transparency = this.image.transparency.indexed;
const isInterlaced = this.image.interlaceMethod === 1;
return this.image.decodePixels(pixels => {
const alphaChannel = new Uint8Array(this.width * this.height);
let i = 0;
for (let j = 0, end = pixels.length; j < end; j++) {
alphaChannel[i++] = transparency[pixels[j]];
}
if (isInterlaced) {
this.imgData = zlib.deflateSync(pixels);
}
this.alphaChannel = zlib.deflateSync(alphaChannel);
return this.finalize();
});
}
decodeData() {
this.image.decodePixels(pixels => {
this.imgData = zlib.deflateSync(pixels);
this.finalize();
});
}
}
class PDFImage {
static open(src, label) {
let data;
if (src instanceof Uint8Array) {
data = src;
} else if (src instanceof ArrayBuffer) {
data = new Uint8Array(src);
} else {
const match = /^data:.+?;base64,(.*)$/.exec(src);
if (match) {
data = fromBase64(match[1]);
} else {
data = fs.readFileSync(src);
if (!data) {
return;
}
}
}
if (data[0] === 0xff && data[1] === 0xd8) {
return new JPEG(data, label);
} else if (data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47) {
return new PNGImage(data, label);
} else {
throw new Error('Unknown image format.');
}
}
}
var ImagesMixin = {
initImages() {
this._imageRegistry = {};
this._imageCount = 0;
},
image(src, x, y, options = {}) {
let bh, bp, bw, image, ip, left, left1, originX, originY;
if (typeof x === 'object') {
options = x;
x = null;
}
const ignoreOrientation = options.ignoreOrientation || options.ignoreOrientation !== false && this.options.ignoreOrientation;
const inDocumentFlow = typeof y !== 'number';
x = (left = x != null ? x : options.x) != null ? left : this.x;
y = (left1 = y != null ? y : options.y) != null ? left1 : this.y;
if (typeof src === 'string') {
image = this._imageRegistry[src];
}
if (!image) {
if (src.width && src.height) {
image = src;
} else {
image = this.openImage(src);
}
}
if (!image.obj) {
image.embed(this);
}
if (this.page.xobjects[image.label] == null) {
this.page.xobjects[image.label] = image.obj;
}
let {
width,
height
} = image;
if (!ignoreOrientation && image.orientation > 4) {
[width, height] = [height, width];
}
let w = options.width || width;
let h = options.height || height;
if (options.width && !options.height) {
const wp = w / width;
w = width * wp;
h = height * wp;
} else if (options.height && !options.width) {
const hp = h / height;
w = width * hp;
h = height * hp;
} else if (options.scale) {
w = width * options.scale;
h = height * options.scale;
} else if (options.fit) {
[bw, bh] = options.fit;
bp = bw / bh;
ip = width / height;
if (ip > bp) {
w = bw;
h = bw / ip;
} else {
h = bh;
w = bh * ip;
}
} else if (options.cover) {
[bw, bh] = options.cover;
bp = bw / bh;
ip = width / height;
if (ip > bp) {
h = bh;
w = bh * ip;
} else {
w = bw;
h = bw / ip;
}
}
if (options.fit || options.cover) {
if (options.align === 'center') {
x = x + bw / 2 - w / 2;
} else if (options.align === 'right') {
x = x + bw - w;
}
if (options.valign === 'center') {
y = y + bh / 2 - h / 2;
} else if (options.valign === 'bottom') {
y = y + bh - h;
}
}
let rotateAngle = 0;
let xTransform = x;
let yTransform = y;
let hTransform = h;
let wTransform = w;
if (!ignoreOrientation) {
switch (image.orientation) {
default:
case 1:
hTransform = -h;
yTransform += h;
break;
case 2:
wTransform = -w;
hTransform = -h;
xTransform += w;
yTransform += h;
break;
case 3:
originX = x;
originY = y;
hTransform = -h;
xTransform -= w;
rotateAngle = 180;
break;
case 4:
break;
case 5:
originX = x;
originY = y;
wTransform = h;
hTransform = w;
yTransform -= hTransform;
rotateAngle = 90;
break;
case 6:
originX = x;
originY = y;
wTransform = h;
hTransform = -w;
rotateAngle = 90;
break;
case 7:
originX = x;
originY = y;
hTransform = -w;
wTransform = -h;
xTransform += h;
rotateAngle = 90;
break;
case 8:
originX = x;
originY = y;
wTransform = h;
hTransform = -w;
xTransform -= h;
yTransform += w;
rotateAngle = -90;
break;
}
} else {
hTransform = -h;
yTransform += h;
}
if (options.link != null) {
this.link(x, y, w, h, options.link);
}
if (options.goTo != null) {
this.goTo(x, y, w, h, options.goTo);
}
if (options.destination != null) {
this.addNamedDestination(options.destination, 'XYZ', x, y, null);
}
if (inDocumentFlow) {
this.y += h;
}
this.save();
if (options.opacity != null) {
this._doOpacity(options.opacity, null);
}
if (rotateAngle) {
this.rotate(rotateAngle, {
origin: [originX, originY]
});
}
this.transform(wTransform, 0, 0, hTransform, xTransform, yTransform);
this.addContent(`/${image.label} Do`);
this.restore();
return this;
},
openImage(src) {
let image;
if (typeof src === 'string') {
image = this._imageRegistry[src];
}
if (!image) {
image = PDFImage.open(src, `I${++this._imageCount}`);
if (typeof src === 'string') {
this._imageRegistry[src] = image;
}
}
return image;
}
};
class PDFAnnotationReference {
constructor(annotationRef) {
this.annotationRef = annotationRef;
}
}
var AnnotationsMixin = {
annotate(x, y, w, h, options) {
const {
structParent,
color,
...annotations
} = options;
annotations.Type = 'Annot';
annotations.Rect = this._convertRect(x, y, w, h);
annotations.Border = [0, 0, 0];
if (annotations.Subtype === 'Link' && typeof annotations.F === 'undefined') {
annotations.F = 1 << 2;
}
if (annotations.Subtype !== 'Link') {
if (annotations.C == null) {
annotations.C = this._normalizeColor(color || [0, 0, 0]);
}
}
if (typeof annotations.Dest === 'string') {
annotations.Dest = new String(annotations.Dest);
}
const ref = this.ref(annotations);
this.page.annotations.push(ref);
if (typeof structParent?.add === 'function') {
const annotRef = new PDFAnnotationReference(ref);
structParent.add(annotRef);
}
ref.end();
return this;
},
note(x, y, w, h, contents, options) {
const annotationOptions = {
...options,
Subtype: 'Text',
Contents: new String(contents)
};
if (annotationOptions.Name == null) {
annotationOptions.Name = 'Comment';
}
if (annotationOptions.color == null) {
annotationOptions.color = [243, 223, 92];
}
return this.annotate(x, y, w, h, annotationOptions);
},
goTo(x, y, w, h, name, options) {
const annotateOptions = {
...options,
Subtype: 'Link',
A: this.ref({
S: 'GoTo',
D: new String(name)
})
};
annotateOptions.A.end();
return this.annotate(x, y, w, h, annotateOptions);
},
link(x, y, w, h, url, options) {
const annotateOptions = {
...options,
Subtype: 'Link'
};
if (typeof url === 'number') {
const pages = this._root.data.Pages.data;
if (url >= 0 && url < pages.Kids.length) {
annotateOptions.A = this.ref({
S: 'GoTo',
D: [pages.Kids[url], 'XYZ', null, null, null]
});
annotateOptions.A.end();
} else {
throw new Error(`The document has no page ${url}`);
}
} else {
annotateOptions.A = this.ref({
S: 'URI',
URI: new String(url)
});
annotateOptions.A.end();
}
if (annotateOptions.structParent && !annotateOptions.Contents) {
annotateOptions.Contents = new String('');
}
return this.annotate(x, y, w, h, annotateOptions);
},
_markup(x, y, w, h, options) {
const [x1, y1, x2, y2] = this._convertRect(x, y, w, h);
return this.annotate(x, y, w, h, {
...options,
QuadPoints: [x1, y2, x2, y2, x1, y1, x2, y1],
Contents: new String()
});
},
highlight(x, y, w, h, options) {
const annotationOptions = {
...options,
Subtype: 'Highlight'
};
if (annotationOptions.color == null) {
annotationOptions.color = [241, 238, 148];
}
return this._markup(x, y, w, h, annotationOptions);
},
underline(x, y, w, h, options) {
const annotationOptions = {
...options,
Subtype: 'Underline'
};
return this._markup(x, y, w, h, annotationOptions);
},
strike(x, y, w, h, options) {
const annotationOptions = {
...options,
Subtype: 'StrikeOut'
};
return this._markup(x, y, w, h, annotationOptions);
},
lineAnnotation(x1, y1, x2, y2, options) {
const annotationOptions = {
...options,
Subtype: 'Line',
Contents: new String(),
L: [x1, this.page.height - y1, x2, this.page.height - y2]
};
return this.annotate(x1, y1, x2, y2, annotationOptions);
},
rectAnnotation(x, y, w, h, options) {
const annotationOptions = {
...options,
Subtype: 'Square',
Contents: new String()
};
return this.annotate(x, y, w, h, annotationOptions);
},
ellipseAnnotation(x, y, w, h, options) {
const annotationOptions = {
...options,
Subtype: 'Circle',
Contents: new String()
};
return this.annotate(x, y, w, h, annotationOptions);
},
textAnnotation(x, y, w, h, text, options) {
const annotationOptions = {
...options,
Subtype: 'FreeText',
Contents: new String(text),
DA: new String()
};
return this.annotate(x, y, w, h, annotationOptions);
},
fileAnnotation(x, y, w, h, file = {}, options) {
const filespec = this.file(file.src, Object.assign({
hidden: true
}, file));
const annotationOptions = {
...options,
Subtype: 'FileAttachment',
FS: filespec
};
if (annotationOptions.Contents) {
annotationOptions.Contents = new String(annotationOptions.Contents);
} else if (filespec.data.Desc) {
annotationOptions.Contents = new String(filespec.data.Desc);
}
return this.annotate(x, y, w, h, annotationOptions);
},
_convertRect(x1, y1, w, h) {
let y2 = y1;
y1 += h;
let x2 = x1 + w;
const [m0, m1, m2, m3, m4, m5] = this._ctm;
x1 = m0 * x1 + m2 * y1 + m4;
y1 = m1 * x1 + m3 * y1 + m5;
x2 = m0 * x2 + m2 * y2 + m4;
y2 = m1 * x2 + m3 * y2 + m5;
return [x1, y1, x2, y2];
}
};
const DEFAULT_OPTIONS = {
top: 0,
left: 0,
zoom: 0,
fit: true,
pageNumber: null,
expanded: false
};
class PDFOutline {
constructor(document, parent, title, dest, options = DEFAULT_OPTIONS) {
this.document = document;
this.options = options;
this.outlineData = {};
if (dest !== null) {
const destWidth = dest.data.MediaBox[2];
const destHeight = dest.data.MediaBox[3];
const top = destHeight - (options.top || 0);
const left = destWidth - (options.left || 0);
const zoom = options.zoom || 0;
this.outlineData['Dest'] = options.fit ? [dest, 'Fit'] : [dest, 'XYZ', left, top, zoom];
}
if (parent !== null) {
this.outlineData['Parent'] = parent;
}
if (title !== null) {
this.outlineData['Title'] = new String(title);
}
this.dictionary = this.document.ref(this.outlineData);
this.children = [];
}
addItem(title, options = DEFAULT_OPTIONS) {
const pages = this.document._root.data.Pages.data.Kids;
const dest = options.pageNumber != null ? pages[options.pageNumber] : this.document.page.dictionary;
const result = new PDFOutline(this.document, this.dictionary, title, dest, options);
this.children.push(result);
return result;
}
endOutline() {
if (this.children.length > 0) {
if (this.options.expanded) {
this.outlineData.Count = this.children.length;
}
const first = this.children[0],
last = this.children[this.children.length - 1];
this.outlineData.First = first.dictionary;
this.outlineData.Last = last.dictionary;
for (let i = 0, len = this.children.length; i < len; i++) {
const child = this.children[i];
if (i > 0) {
child.outlineData.Prev = this.children[i - 1].dictionary;
}
if (i < this.children.length - 1) {
child.outlineData.Next = this.children[i + 1].dictionary;
}
child.endOutline();
}
}
return this.dictionary.end();
}
}
var OutlineMixin = {
initOutline() {
this.outline = new PDFOutline(this, null, null, null);
},
endOutline() {
this.outline.endOutline();
if (this.outline.children.length > 0) {
this._root.data.Outlines = this.outline.dictionary;
return this._root.data.PageMode = this._root.data.PageMode || 'UseOutlines';
}
}
};
class PDFStructureContent {
constructor(pageRef, mcid) {
this.refs = [{
pageRef,
mcid
}];
}
push(structContent) {
structContent.refs.forEach(ref => this.refs.push(ref));
}
}
class PDFStructureElement {
constructor(document, type, options = {}, children = null) {
this.document = document;
this._attached = false;
this._ended = false;
this._flushed = false;
this.dictionary = document.ref({
S: type
});
const data = this.dictionary.data;
if (Array.isArray(options) || this._isValidChild(options)) {
children = options;
options = {};
}
if (options.title) {
data.T = new String(options.title);
}
if (options.lang) {
data.Lang = new String(options.lang);
}
if (options.alt) {
data.Alt = new String(options.alt);
}
if (options.expanded) {
data.E = new String(options.expanded);
}
if (options.actual) {
data.ActualText = new String(options.actual);
}
const hasBbox = Array.isArray(options.bbox) && options.bbox.length === 4;
const hasPlacement = typeof options.placement === 'string';
if (hasBbox || hasPlacement) {
const attrs = {
O: 'Layout'
};
attrs.Placement = hasPlacement ? options.placement : 'Block';
if (hasBbox) {
const height = document.page.height;
attrs.BBox = [options.bbox[0], height - options.bbox[3], options.bbox[2], height - options.bbox[1]];
}
data.A = attrs;
}
if (options.scope) {
data.A = {
...(data.A || {}),
O: 'Table',
Scope: options.scope
};
}
this._children = [];
if (children) {
if (!Array.isArray(children)) {
children = [children];
}
children.forEach(child => this.add(child));
this.end();
}
}
add(child) {
if (this._ended) {
throw new Error(`Cannot add child to already-ended structure element`);
}
if (!this._isValidChild(child)) {
throw new Error(`Invalid structure element child`);
}
if (child instanceof PDFStructureElement) {
child.setParent(this.dictionary);
if (this._attached) {
child.setAttached();
}
}
if (child instanceof PDFStructureContent) {
this._addContentToParentTree(child);
}
if (child instanceof PDFAnnotationReference) {
this._addAnnotationToParentTree(child.annotationRef);
}
if (typeof child === 'function' && this._attached) {
child = this._contentForClosure(child);
}
this._children.push(child);
return this;
}
_addContentToParentTree(content) {
content.refs.forEach(({
pageRef,
mcid
}) => {
const pageStructParents = this.document.getStructParentTree().get(pageRef.data.StructParents);
pageStructParents[mcid] = this.dictionary;
});
}
_addAnnotationToParentTree(annotRef) {
const parentTreeKey = this.document.createStructParentTreeNextKey();
annotRef.data.StructParent = parentTreeKey;
const parentTree = this.document.getStructParentTree();
parentTree.add(parentTreeKey, this.dictionary);
}
setParent(parentRef) {
if (this.dictionary.data.P) {
throw new Error(`Structure element added to more than one parent`);
}
this.dictionary.data.P = parentRef;
this._flush();
}
setAttached() {
if (this._attached) {
return;
}
this._children.forEach((child, index) => {
if (child instanceof PDFStructureElement) {
child.setAttached();
}
if (typeof child === 'function') {
this._children[index] = this._contentForClosure(child);
}
});
this._attached = true;
this._flush();
}
end() {
if (this._ended) {
return;
}
this._children.filter(child => child instanceof PDFStructureElement).forEach(child => child.end());
this._ended = true;
this._flush();
}
_isValidChild(child) {
return child instanceof PDFStructureElement || child instanceof PDFStructureContent || child instanceof PDFAnnotationReference || typeof child === 'function';
}
_contentForClosure(closure) {
const content = this.document.markStructureContent(this.dictionary.data.S);
const prevStructElement = this.document._currentStructureElement;
this.document._currentStructureElement = this;
const wasEnded = this._ended;
this._ended = false;
closure();
this._ended = wasEnded;
this.document._currentStructureElement = prevStructElement;
this.document.endMarkedContent();
this._addContentToParentTree(content);
return content;
}
_isFlushable() {
if (!this.dictionary.data.P || !this._ended) {
return false;
}
return this._children.every(child => {
if (typeof child === 'function') {
return false;
}
if (child instanceof PDFStructureElement) {
return child._isFlushable();
}
return true;
});
}
_flush() {
if (this._flushed || !this._isFlushable()) {
return;
}
this.dictionary.data.K = [];
this._children.forEach(child => this._flushChild(child));
this.dictionary.end();
this._children = [];
this.dictionary.data.K = null;
this._flushed = true;
}
_flushChild(child) {
if (child instanceof PDFStructureElement) {
this.dictionary.data.K.push(child.dictionary);
}
if (child instanceof PDFStructureContent) {
child.refs.forEach(({
pageRef,
mcid
}) => {
if (!this.dictionary.data.Pg) {
this.dictionary.data.Pg = pageRef;
}
if (this.dictionary.data.Pg === pageRef) {
this.dictionary.data.K.push(mcid);
} else {
this.dictionary.data.K.push({
Type: 'MCR',
Pg: pageRef,
MCID: mcid
});
}
});
}
if (child instanceof PDFAnnotationReference) {
const pageRef = this.document.page.dictionary;
const objr = {
Type: 'OBJR',
Obj: child.annotationRef,
Pg: pageRef
};
this.dictionary.data.K.push(objr);
}
}
}
class PDFNumberTree extends PDFTree {
_compareKeys(a, b) {
return parseInt(a) - parseInt(b);
}
_keysName() {
return 'Nums';
}
_dataForKey(k) {
return parseInt(k);
}
}
var MarkingsMixin = {
initMarkings(options) {
this.structChildren = [];
if (options.tagged) {
this.getMarkInfoDictionary().data.Marked = true;
this.getStructTreeRoot();
}
},
markContent(tag, options = null) {
if (tag === 'Artifact' || options && options.mcid) {
let toClose = 0;
this.page.markings.forEach(marking => {
if (toClose || marking.structContent || marking.tag === 'Artifact') {
toClose++;
}
});
while (toClose--) {
this.endMarkedContent();
}
}
if (!options) {
this.page.markings.push({
tag
});
this.addContent(`/${tag} BMC`);
return this;
}
this.page.markings.push({
tag,
options
});
const dictionary = {};
if (typeof options.mcid !== 'undefined') {
dictionary.MCID = options.mcid;
}
if (tag === 'Artifact') {
if (typeof options.type === 'string') {
dictionary.Type = options.type;
}
if (Array.isArray(options.bbox)) {
dictionary.BBox = [options.bbox[0], this.page.height - options.bbox[3], options.bbox[2], this.page.height - options.bbox[1]];
}
if (Array.isArray(options.attached) && options.attached.every(val => typeof val === 'string')) {
dictionary.Attached = options.attached;
}
}
if (tag === 'Span') {
if (options.lang) {
dictionary.Lang = new String(options.lang);
}
if (options.alt) {
dictionary.Alt = new String(options.alt);
}
if (options.expanded) {
dictionary.E = new String(options.expanded);
}
if (options.actual) {
dictionary.ActualText = new String(options.actual);
}
}
this.addContent(`/${tag} ${PDFObject.convert(dictionary)} BDC`);
return this;
},
markStructureContent(tag, options = {}) {
const pageStructParents = this.getStructParentTree().get(this.page.structParentTreeKey);
const mcid = pageStructParents.length;
pageStructParents.push(null);
this.markContent(tag, {
...options,
mcid
});
const structContent = new PDFStructureContent(this.page.dictionary, mcid);
this.page.markings.slice(-1)[0].structContent = structContent;
return structContent;
},
endMarkedContent() {
this.page.markings.pop();
this.addContent('EMC');
if (this._textOptions) {
delete this._textOptions.link;
delete this._textOptions.goTo;
delete this._textOptions.destination;
delete this._textOptions.underline;
delete this._textOptions.strike;
}
return this;
},
struct(type, options = {}, children = null) {
return new PDFStructureElement(this, type, options, children);
},
addStructure(structElem) {
const structTreeRoot = this.getStructTreeRoot();
structElem.setParent(structTreeRoot);
structElem.setAttached();
this.structChildren.push(structElem);
if (!structTreeRoot.data.K) {
structTreeRoot.data.K = [];
}
structTreeRoot.data.K.push(structElem.dictionary);
return this;
},
initPageMarkings(pageMarkings) {
pageMarkings.forEach(marking => {
if (marking.structContent) {
const structContent = marking.structContent;
const newStructContent = this.markStructureContent(marking.tag, marking.options);
structContent.push(newStructContent);
this.page.markings.slice(-1)[0].structContent = structContent;
} else {
this.markContent(marking.tag, marking.options);
}
});
},
endPageMarkings(page) {
const pageMarkings = page.markings;
pageMarkings.forEach(() => page.write('EMC'));
page.markings = [];
return pageMarkings;
},
getMarkInfoDictionary() {
if (!this._root.data.MarkInfo) {
this._root.data.MarkInfo = this.ref({});
}
return this._root.data.MarkInfo;
},
hasMarkInfoDictionary() {
return !!this._root.data.MarkInfo;
},
getStructTreeRoot() {
if (!this._root.data.StructTreeRoot) {
this._root.data.StructTreeRoot = this.ref({
Type: 'StructTreeRoot',
ParentTree: new PDFNumberTree(),
ParentTreeNextKey: 0
});
}
return this._root.data.StructTreeRoot;
},
getStructParentTree() {
return this.getStructTreeRoot().data.ParentTree;
},
createStructParentTreeNextKey() {
this.getMarkInfoDictionary();
const structTreeRoot = this.getStructTreeRoot();
const key = structTreeRoot.data.ParentTreeNextKey++;
structTreeRoot.data.ParentTree.add(key, []);
return key;
},
endMarkings() {
const structTreeRoot = this._root.data.StructTreeRoot;
if (structTreeRoot) {
structTreeRoot.end();
this.structChildren.forEach(structElem => structElem.end());
}
if (this._root.data.MarkInfo) {
this._root.data.MarkInfo.end();
}
}
};
const FIELD_FLAGS = {
readOnly: 1,
required: 2,
noExport: 4,
multiline: 0x1000,
password: 0x2000,
toggleToOffButton: 0x4000,
radioButton: 0x8000,
pushButton: 0x10000,
combo: 0x20000,
edit: 0x40000,
sort: 0x80000,
multiSelect: 0x200000,
noSpell: 0x400000
};
const FIELD_JUSTIFY = {
left: 0,
center: 1,
right: 2
};
const VALUE_MAP = {
value: 'V',
defaultValue: 'DV'
};
const FORMAT_SPECIAL = {
zip: '0',
zipPlus4: '1',
zip4: '1',
phone: '2',
ssn: '3'
};
const FORMAT_DEFAULT = {
number: {
nDec: 0,
sepComma: false,
negStyle: 'MinusBlack',
currency: '',
currencyPrepend: true
},
percent: {
nDec: 0,
sepComma: false
}
};
function mapTypeAndFlags(type, userOptions, pdfObject) {
let flags = userOptions.Ff ?? 0;
if (type === 'text') {
pdfObject.FT = 'Tx';
} else if (type === 'pushButton') {
pdfObject.FT = 'Btn';
flags |= FIELD_FLAGS.pushButton;
} else if (type === 'radioButton') {
pdfObject.FT = 'Btn';
flags |= FIELD_FLAGS.radioButton;
} else if (type === 'checkbox') {
pdfObject.FT = 'Btn';
} else if (type === 'combo') {
pdfObject.FT = 'Ch';
flags |= FIELD_FLAGS.combo;
} else if (type === 'list') {
pdfObject.FT = 'Ch';
} else if (type) {
throw new Error(`Invalid form annotation type '${type}'`);
}
Object.keys(userOptions).forEach(key => {
if (FIELD_FLAGS[key] && userOptions[key]) {
flags |= FIELD_FLAGS[key];
}
});
if (flags !== 0) {
pdfObject.Ff = flags;
}
}
function mapJustify(userOptions, pdfObject) {
const result = FIELD_JUSTIFY[userOptions.align];
if (typeof result === 'number' && result !== 0) {
pdfObject.Q = result;
}
}
function mapStrings(options, pdfObject) {
if (Array.isArray(options.select) && options.select.length) {
pdfObject.Opt = options.select.map(s => {
if (typeof s === 'string') {
return new String(s);
}
return s;
});
}
Object.keys(VALUE_MAP).forEach(key => {
if (key in options) {
const value = options[key] ?? '';
pdfObject[VALUE_MAP[key]] = typeof value === 'string' ? new String(value) : value;
}
});
if (options.MK?.CA) {
pdfObject.MK = {
CA: new String(options.MK.CA)
};
}
if (options.label) {
pdfObject.MK = options.MK ?? {};
pdfObject.MK.CA = new String(options.label);
}
}
function mapFormat(options, pdfObject) {
const f = options.format;
if (f?.type) {
let fnKeystroke;
let fnFormat;
let params = '';
if (FORMAT_SPECIAL[f.type] !== undefined) {
fnKeystroke = `AFSpecial_Keystroke`;
fnFormat = `AFSpecial_Format`;
params = FORMAT_SPECIAL[f.type];
} else {
let format = f.type.charAt(0).toUpperCase() + f.type.slice(1);
fnKeystroke = `AF${format}_Keystroke`;
fnFormat = `AF${format}_Format`;
if (f.type === 'date') {
fnKeystroke += 'Ex';
fnFormat += 'Ex';
params = '"' + String(f.param) + '"';
} else if (f.type === 'time') {
params = String(f.param);
} else if (f.type === 'number') {
let p = Object.assign({}, FORMAT_DEFAULT.number, f);
params = String([String(p.nDec), p.sepComma ? '0' : '1', '"' + p.negStyle + '"', 'null', '"' + p.currency + '"', String(p.currencyPrepend)].join(','));
} else if (f.type === 'percent') {
let p = Object.assign({}, FORMAT_DEFAULT.percent, f);
params = String([String(p.nDec), p.sepComma ? '0' : '1'].join(','));
}
}
pdfObject.AA = options.AA ?? {};
pdfObject.AA.K = {
S: 'JavaScript',
JS: new String(`${fnKeystroke}(${params});`)
};
pdfObject.AA.F = {
S: 'JavaScript',
JS: new String(`${fnFormat}(${params});`)
};
}
}
var AcroFormMixin = {
initForm() {
if (!this._font) {
throw new Error('Must set a font before calling initForm method');
}
this._acroform = {
fonts: {},
defaultFont: this._font.name
};
this._acroform.fonts[this._font.id] = this._font.ref();
let data = {
Fields: [],
NeedAppearances: true,
DA: new String(`/${this._font.id} 0 Tf 0 g`),
DR: {
Font: {}
}
};
data.DR.Font[this._font.id] = this._font.ref();
const AcroForm = this.ref(data);
this._root.data.AcroForm = AcroForm;
return this;
},
endAcroForm() {
if (this._root.data.AcroForm) {
if (!Object.keys(this._acroform.fonts).length && !this._acroform.defaultFont) {
throw new Error('No fonts specified for PDF form');
}
let fontDict = this._root.data.AcroForm.data.DR.Font;
Object.keys(this._acroform.fonts).forEach(name => {
fontDict[name] = this._acroform.fonts[name];
});
this._root.data.AcroForm.data.Fields.forEach(fieldRef => {
this._endChild(fieldRef);
});
this._root.data.AcroForm.end();
}
return this;
},
_endChild(ref) {
if (Array.isArray(ref.data.Kids)) {
ref.data.Kids.forEach(childRef => {
this._endChild(childRef);
});
ref.end();
}
return this;
},
formField(name, options = {}) {
let fieldDict = this._fieldDict(name, null, options);
let fieldRef = this.ref(fieldDict);
this._addToParent(fieldRef);
return fieldRef;
},
formAnnotation(name, type, x, y, w, h, options = {}) {
let fieldDict = this._fieldDict(name, type, options);
fieldDict.Subtype = 'Widget';
if (fieldDict.F === undefined) {
fieldDict.F = 4;
}
this.annotate(x, y, w, h, fieldDict);
let annotRef = this.page.annotations[this.page.annotations.length - 1];
return this._addToParent(annotRef);
},
formText(name, x, y, w, h, options = {}) {
return this.formAnnotation(name, 'text', x, y, w, h, options);
},
formPushButton(name, x, y, w, h, options = {}) {
return this.formAnnotation(name, 'pushButton', x, y, w, h, options);
},
formCombo(name, x, y, w, h, options = {}) {
return this.formAnnotation(name, 'combo', x, y, w, h, options);
},
formList(name, x, y, w, h, options = {}) {
return this.formAnnotation(name, 'list', x, y, w, h, options);
},
formRadioButton(name, x, y, w, h, options = {}) {
return this.formAnnotation(name, 'radioButton', x, y, w, h, options);
},
formCheckbox(name, x, y, w, h, options = {}) {
return this.formAnnotation(name, 'checkbox', x, y, w, h, options);
},
_addToParent(fieldRef) {
let parent = fieldRef.data.Parent;
if (parent) {
if (!parent.data.Kids) {
parent.data.Kids = [];
}
parent.data.Kids.push(fieldRef);
} else {
this._root.data.AcroForm.data.Fields.push(fieldRef);
}
return this;
},
_fieldDict(name, type, options = {}) {
if (!this._acroform) {
throw new Error('Call document.initForm() method before adding form elements to document');
}
const pdfObject = {};
mapTypeAndFlags(type, options, pdfObject);
mapJustify(options, pdfObject);
this._mapFont(options, pdfObject);
mapStrings(options, pdfObject);
this._mapColors(options, pdfObject);
mapFormat(options, pdfObject);
pdfObject.T = new String(name);
if (options.parent) {
pdfObject.Parent = options.parent;
}
return pdfObject;
},
_mapColors(options, pdfObject) {
let color = this._normalizeColor(options.backgroundColor);
if (color) {
pdfObject.MK = pdfObject.MK ? pdfObject.MK : {};
pdfObject.MK.BG = color;
}
color = this._normalizeColor(options.borderColor);
if (color) {
if (!pdfObject.MK) {
pdfObject.MK = {};
}
pdfObject.MK.BC = color;
}
},
_mapFont(options, pdfObject) {
const {
_acroform,
_font
} = this;
if (_acroform.fonts[_font.id] == null) {
_acroform.fonts[_font.id] = _font.ref();
}
if (_acroform.defaultFont !== _font.name) {
pdfObject.DR = {
Font: {}
};
const fontSize = options.fontSize || 0;
pdfObject.DR.Font[_font.id] = _font.ref();
pdfObject.DA = new String(`/${_font.id} ${fontSize} Tf 0 g`);
}
}
};
var AttachmentsMixin = {
file(src, options = {}) {
options.name = options.name || src;
options.relationship = options.relationship || 'Unspecified';
const refBody = {
Type: 'EmbeddedFile',
Params: {}
};
let data;
if (!src) {
throw new Error('No src specified');
}
if (src instanceof Uint8Array) {
data = src;
} else if (src instanceof ArrayBuffer) {
data = new Uint8Array(src);
} else {
const match = /^data:(.*?);base64,(.*)$/.exec(src);
if (match) {
if (match[1]) {
refBody.Subtype = escapeName(match[1]);
}
data = fromBase64(match[2]);
} else {
data = fs.readFileSync(src);
if (!data) {
throw new Error(`Could not read contents of file at filepath ${src}`);
}
const {
birthtime,
ctime
} = fs.statSync(src);
refBody.Params.CreationDate = birthtime;
refBody.Params.ModDate = ctime;
}
}
if (options.creationDate instanceof Date) {
refBody.Params.CreationDate = options.creationDate;
}
if (options.modifiedDate instanceof Date) {
refBody.Params.ModDate = options.modifiedDate;
}
if (options.type) {
refBody.Subtype = escapeName(options.type);
}
const checksum = md5Hex(new Uint8Array(data));
refBody.Params.CheckSum = new String(checksum);
refBody.Params.Size = data.byteLength;
let ref;
if (!this._fileRegistry) this._fileRegistry = {};
let file = this._fileRegistry[options.name];
if (file && isEqual(refBody, file)) {
ref = file.ref;
} else {
ref = this.ref(refBody);
ref.end(data);
this._fileRegistry[options.name] = {
...refBody,
ref
};
}
const fileSpecBody = {
Type: 'Filespec',
AFRelationship: options.relationship,
F: new String(options.name),
EF: {
F: ref
},
UF: new String(options.name)
};
if (options.description) {
fileSpecBody.Desc = new String(options.description);
}
const filespec = this.ref(fileSpecBody);
filespec.end();
if (!options.hidden) {
this.addNamedEmbeddedFile(options.name, filespec);
}
if (this._root.data.AF) {
this._root.data.AF.push(filespec);
} else {
this._root.data.AF = [filespec];
}
return filespec;
}
};
function isEqual(a, b) {
return a.Subtype === b.Subtype && a.Params.CheckSum.toString() === b.Params.CheckSum.toString() && a.Params.Size === b.Params.Size && a.Params.CreationDate.getTime() === b.Params.CreationDate.getTime() && (a.Params.ModDate === undefined && b.Params.ModDate === undefined || a.Params.ModDate.getTime() === b.Params.ModDate.getTime());
}
const ICC_PROFILE_PATH = new URL('./data/sRGB_IEC61966_2_1.icc', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('pdfkit.browser.js', document.baseURI).href))).href;
let iccProfile;
var PDFA = {
initPDFA(pSubset) {
if (pSubset.charAt(pSubset.length - 3) === '-') {
this.subset_conformance = pSubset.charAt(pSubset.length - 1).toUpperCase();
this.subset = parseInt(pSubset.charAt(pSubset.length - 2));
} else {
this.subset_conformance = 'B';
this.subset = parseInt(pSubset.charAt(pSubset.length - 1));
}
},
endSubset() {
this._addPdfaMetadata();
this._addColorOutputIntent();
},
_addColorOutputIntent() {
if (!iccProfile) {
iccProfile = fs.readFileSync(ICC_PROFILE_PATH);
}
const colorProfileRef = this.ref({
Length: iccProfile.length,
N: 3
});
colorProfileRef.write(iccProfile);
colorProfileRef.end();
const intentRef = this.ref({
Type: 'OutputIntent',
S: 'GTS_PDFA1',
Info: new String('sRGB IEC61966-2.1'),
OutputConditionIdentifier: new String('sRGB IEC61966-2.1'),
DestOutputProfile: colorProfileRef
});
intentRef.end();
this._root.data.OutputIntents = [intentRef];
},
_getPdfaid() {
return `
<rdf:Description xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/" rdf:about="">
<pdfaid:part>${this.subset}</pdfaid:part>
<pdfaid:conformance>${this.subset_conformance}</pdfaid:conformance>
</rdf:Description>
`;
},
_addPdfaMetadata() {
this.appendXML(this._getPdfaid());
}
};
var PDFUA = {
initPDFUA() {
this.subset = 1;
},
endSubset() {
this._addPdfuaMetadata();
},
_addPdfuaMetadata() {
this.appendXML(this._getPdfuaid());
},
_getPdfuaid() {
return `
<rdf:Description xmlns:pdfuaid="http://www.aiim.org/pdfua/ns/id/" rdf:about="">
<pdfuaid:part>${this.subset}</pdfuaid:part>
</rdf:Description>
`;
}
};
var SubsetMixin = {
_importSubset(subset) {
Object.assign(this, subset);
},
initSubset(options) {
switch (options.subset) {
case 'PDF/A-1':
case 'PDF/A-1a':
case 'PDF/A-1b':
case 'PDF/A-2':
case 'PDF/A-2a':
case 'PDF/A-2b':
case 'PDF/A-3':
case 'PDF/A-3a':
case 'PDF/A-3b':
this._importSubset(PDFA);
this.initPDFA(options.subset);
break;
case 'PDF/UA':
this._importSubset(PDFUA);
this.initPDFUA();
break;
}
}
};
const ROW_FIELDS = ['height', 'minHeight', 'maxHeight'];
const COLUMN_FIELDS = ['width', 'minWidth', 'maxWidth'];
function memoize(fn, maxSize) {
const cache = new Map();
return function (...args) {
const key = args[0];
if (!cache.has(key)) {
cache.set(key, fn(...args));
if (cache.size > maxSize) cache.delete(cache.keys().next());
}
return cache.get(key);
};
}
function isObject(item) {
return item && typeof item === 'object' && !Array.isArray(item);
}
function deepMerge(target, ...sources) {
if (!isObject(target)) return target;
target = deepClone(target);
for (const source of sources) {
if (isObject(source)) {
for (const key in source) {
if (isObject(source[key])) {
if (!(key in target)) target[key] = {};
target[key] = deepMerge(target[key], source[key]);
} else if (source[key] !== undefined) {
target[key] = deepClone(source[key]);
}
}
}
}
return target;
}
function deepClone(obj) {
let result = obj;
if (obj && typeof obj == 'object') {
result = Array.isArray(obj) ? [] : {};
for (const key in obj) result[key] = deepClone(obj[key]);
}
return result;
}
function normalizedDefaultStyle(defaultStyleInternal) {
let defaultStyle = defaultStyleInternal;
if (typeof defaultStyle !== 'object') defaultStyle = {
text: defaultStyle
};
const defaultRowStyle = Object.fromEntries(Object.entries(defaultStyle).filter(([k]) => ROW_FIELDS.includes(k)));
const defaultColStyle = Object.fromEntries(Object.entries(defaultStyle).filter(([k]) => COLUMN_FIELDS.includes(k)));
defaultStyle.padding = normalizeSides(defaultStyle.padding);
defaultStyle.border = normalizeSides(defaultStyle.border);
defaultStyle.borderColor = normalizeSides(defaultStyle.borderColor);
defaultStyle.align = normalizeAlignment(defaultStyle.align);
return {
defaultStyle,
defaultRowStyle,
defaultColStyle
};
}
function normalizedRowStyle(defaultRowStyle, rowStyleInternal, i) {
let rowStyle = rowStyleInternal(i);
if (rowStyle == null || typeof rowStyle !== 'object') {
rowStyle = {
height: rowStyle
};
}
rowStyle.padding = normalizeSides(rowStyle.padding);
rowStyle.border = normalizeSides(rowStyle.border);
rowStyle.borderColor = normalizeSides(rowStyle.borderColor);
rowStyle.align = normalizeAlignment(rowStyle.align);
rowStyle = deepMerge(defaultRowStyle, rowStyle);
const document = this.document;
const page = document.page;
const contentHeight = page.contentHeight;
if (rowStyle.height == null || rowStyle.height === 'auto') {
rowStyle.height = 'auto';
} else {
rowStyle.height = document.sizeToPoint(rowStyle.height, 0, page, contentHeight);
}
rowStyle.minHeight = document.sizeToPoint(rowStyle.minHeight, 0, page, contentHeight);
rowStyle.maxHeight = document.sizeToPoint(rowStyle.maxHeight, 0, page, contentHeight);
return rowStyle;
}
function normalizedColumnStyle(defaultColStyle, colStyleInternal, i) {
let colStyle = colStyleInternal(i);
if (colStyle == null || typeof colStyle !== 'object') {
colStyle = {
width: colStyle
};
}
colStyle.padding = normalizeSides(colStyle.padding);
colStyle.border = normalizeSides(colStyle.border);
colStyle.borderColor = normalizeSides(colStyle.borderColor);
colStyle.align = normalizeAlignment(colStyle.align);
colStyle = deepMerge(defaultColStyle, colStyle);
if (colStyle.width == null || colStyle.width === '*') {
colStyle.width = '*';
} else {
colStyle.width = this.document.sizeToPoint(colStyle.width, 0, this.document.page, this._maxWidth);
}
colStyle.minWidth = this.document.sizeToPoint(colStyle.minWidth, 0, this.document.page, this._maxWidth);
colStyle.maxWidth = this.document.sizeToPoint(colStyle.maxWidth, 0, this.document.page, this._maxWidth);
return colStyle;
}
function normalizeAlignment(align) {
return align == null || typeof align === 'string' ? {
x: align,
y: align
} : align;
}
function normalizeTable() {
const doc = this.document;
const opts = this.opts;
let index = doc._tableIndex++;
this._id = new String(opts.id ?? `table-${index}`);
this._position = {
x: doc.sizeToPoint(opts.position?.x, doc.x),
y: doc.sizeToPoint(opts.position?.y, doc.y)
};
this._maxWidth = doc.sizeToPoint(opts.maxWidth, doc.page.width - doc.page.margins.right - this._position.x);
const {
defaultStyle,
defaultColStyle,
defaultRowStyle
} = normalizedDefaultStyle(opts.defaultStyle);
this._defaultStyle = defaultStyle;
let colStyle;
if (opts.columnStyles) {
if (Array.isArray(opts.columnStyles)) {
colStyle = i => opts.columnStyles[i];
} else if (typeof opts.columnStyles === 'function') {
colStyle = memoize(i => opts.columnStyles(i), Infinity);
} else if (typeof opts.columnStyles === 'object') {
colStyle = () => opts.columnStyles;
}
}
if (!colStyle) colStyle = () => ({});
this._colStyle = normalizedColumnStyle.bind(this, defaultColStyle, colStyle);
let rowStyle;
if (opts.rowStyles) {
if (Array.isArray(opts.rowStyles)) {
rowStyle = i => opts.rowStyles[i];
} else if (typeof opts.rowStyles === 'function') {
rowStyle = memoize(i => opts.rowStyles(i), 10);
} else if (typeof opts.rowStyles === 'object') {
rowStyle = () => opts.rowStyles;
}
}
if (!rowStyle) rowStyle = () => ({});
this._rowStyle = normalizedRowStyle.bind(this, defaultRowStyle, rowStyle);
}
function normalizeText(text) {
if (text != null) text = `${text}`;
return text;
}
function normalizeCell(cell, rowIndex, colIndex) {
const colStyle = this._colStyle(colIndex);
let rowStyle = this._rowStyle(rowIndex);
const font = {};
for (const level of [colStyle.font, rowStyle.font, cell.font]) {
if (level == null) continue;
if (level.src != null) {
font.src = level.src;
font.family = level.family;
} else if (level.family != null) {
font.family = level.family;
}
if (level.size != null) font.size = level.size;
}
const customFont = Object.values(font).filter(v => v != null).length > 0;
const doc = this.document;
const rollbackFont = doc._fontSource;
const rollbackFontSize = doc._fontSize;
const rollbackFontFamily = doc._fontFamily;
if (customFont) {
if (font.src) doc.font(font.src, font.family);
if (font.size) doc.fontSize(font.size);
rowStyle = this._rowStyle(rowIndex);
}
cell.padding = normalizeSides(cell.padding);
cell.border = normalizeSides(cell.border);
cell.borderColor = normalizeSides(cell.borderColor);
const config = deepMerge(this._defaultStyle, colStyle, rowStyle, cell);
config.rowIndex = rowIndex;
config.colIndex = colIndex;
config.font = font ?? {};
config.customFont = customFont;
config.text = normalizeText(config.text);
config.rowSpan = config.rowSpan ?? 1;
config.colSpan = config.colSpan ?? 1;
config.padding = normalizeSides(config.padding, '0.25em', x => doc.sizeToPoint(x, '0.25em'));
config.border = normalizeSides(config.border, 1, x => doc.sizeToPoint(x, 1));
config.borderColor = normalizeSides(config.borderColor, 'black', x => x ?? 'black');
config.align = normalizeAlignment(config.align);
config.align.x = config.align.x ?? 'left';
config.align.y = config.align.y ?? 'top';
config.textStroke = doc.sizeToPoint(config.textStroke, 0);
config.textStrokeColor = config.textStrokeColor ?? 'black';
config.textColor = config.textColor ?? 'black';
config.textOptions = config.textOptions ?? {};
config.id = new String(config.id ?? `${this._id}-${rowIndex}-${colIndex}`);
config.type = config.type?.toUpperCase() === 'TH' ? 'TH' : 'TD';
if (config.scope) {
config.scope = config.scope.toLowerCase();
if (config.scope === 'row') config.scope = 'Row';else if (config.scope === 'both') config.scope = 'Both';else if (config.scope === 'column') config.scope = 'Column';
}
if (typeof this.opts.debug === 'boolean') config.debug = this.opts.debug;
if (customFont) doc.font(rollbackFont, rollbackFontFamily, rollbackFontSize);
return config;
}
function normalizeRow(row, rowIndex) {
if (!this._cellClaim) this._cellClaim = new Set();
let colIndex = 0;
return row.map(cell => {
if (cell == null || typeof cell !== 'object') cell = {
text: cell
};
while (this._cellClaim.has(`${rowIndex},${colIndex}`)) {
colIndex++;
}
cell = normalizeCell.call(this, cell, rowIndex, colIndex);
for (let i = 0; i < cell.rowSpan; i++) {
for (let j = 0; j < cell.colSpan; j++) {
this._cellClaim.add(`${rowIndex + i},${colIndex + j}`);
}
}
colIndex += cell.colSpan;
return cell;
});
}
function ensure(row) {
this._columnWidths = [];
ensureColumnWidths.call(this, row.reduce((a, cell) => a + cell.colSpan, 0));
this._rowHeights = [];
this._rowYPos = [this._position.y];
this._rowBuffer = new Set();
}
function ensureColumnWidths(numCols) {
let starColumnIndexes = [];
let starMinAcc = 0;
let unclaimedWidth = this._maxWidth;
for (let i = 0; i < numCols; i++) {
let col = this._colStyle(i);
if (col.width === '*') {
starColumnIndexes[i] = col;
starMinAcc += col.minWidth;
} else {
unclaimedWidth -= col.width;
this._columnWidths[i] = col.width;
}
}
let starColCount = starColumnIndexes.reduce(x => x + 1, 0);
if (starMinAcc >= unclaimedWidth) {
starColumnIndexes.forEach((cell, i) => {
this._columnWidths[i] = cell.minWidth;
});
} else if (starColCount > 0) {
starColumnIndexes.forEach((col, i) => {
let starSize = unclaimedWidth / starColCount;
this._columnWidths[i] = Math.max(starSize, col.minWidth);
if (col.maxWidth > 0) {
this._columnWidths[i] = Math.min(this._columnWidths[i], col.maxWidth);
}
unclaimedWidth -= this._columnWidths[i];
starColCount--;
});
}
let tempX = this._position.x;
this._columnXPos = Array.from(this._columnWidths, v => {
const t = tempX;
tempX += v;
return t;
});
}
function measure(row, rowIndex) {
row.forEach(cell => this._rowBuffer.add(cell));
if (rowIndex > 0) {
this._rowYPos[rowIndex] = this._rowYPos[rowIndex - 1] + this._rowHeights[rowIndex - 1];
}
const rowStyle = this._rowStyle(rowIndex);
let toRender = [];
this._rowBuffer.forEach(cell => {
if (cell.rowIndex + cell.rowSpan - 1 === rowIndex) {
toRender.push(measureCell.call(this, cell, rowStyle.height));
this._rowBuffer.delete(cell);
}
});
let rowHeight = rowStyle.height;
if (rowHeight === 'auto') {
rowHeight = toRender.reduce((acc, cell) => {
let minHeight = cell.textBounds.height + cell.padding.top + cell.padding.bottom;
for (let i = 0; i < cell.rowSpan - 1; i++) {
minHeight -= this._rowHeights[cell.rowIndex + i];
}
return Math.max(acc, minHeight);
}, 0);
}
rowHeight = Math.max(rowHeight, rowStyle.minHeight);
if (rowStyle.maxHeight > 0) {
rowHeight = Math.min(rowHeight, rowStyle.maxHeight);
}
this._rowHeights[rowIndex] = rowHeight;
let newPage = false;
if (rowHeight > this.document.page.contentHeight) {
console.warn(new Error(`Row ${rowIndex} requested more than the safe page height, row has been clamped`).stack.slice(7));
this._rowHeights[rowIndex] = this.document.page.maxY() - this._rowYPos[rowIndex];
} else if (this._rowYPos[rowIndex] + rowHeight >= this.document.page.maxY()) {
this._rowYPos[rowIndex] = this.document.page.margins.top;
newPage = true;
}
return {
newPage,
toRender: toRender.map(cell => measureCell.call(this, cell, rowHeight))
};
}
function measureCell(cell, rowHeight) {
let cellWidth = 0;
for (let i = 0; i < cell.colSpan; i++) {
cellWidth += this._columnWidths[cell.colIndex + i];
}
let cellHeight = rowHeight;
if (cellHeight === 'auto') {
cellHeight = this.document.page.contentHeight;
} else {
for (let i = 0; i < cell.rowSpan - 1; i++) {
cellHeight += this._rowHeights[cell.rowIndex + i];
}
}
const textAllocatedWidth = cellWidth - cell.padding.left - cell.padding.right;
const textAllocatedHeight = cellHeight - cell.padding.top - cell.padding.bottom;
const rotation = cell.textOptions.rotation ?? 0;
const {
width: textMaxWidth,
height: textMaxHeight
} = computeBounds(rotation, textAllocatedWidth, textAllocatedHeight);
const textOptions = {
align: cell.align.x,
ellipsis: true,
stroke: cell.textStroke > 0,
fill: true,
width: textMaxWidth,
height: textMaxHeight,
rotation,
...cell.textOptions
};
let textBounds = {
x: 0,
y: 0,
width: 0,
height: 0
};
if (cell.text) {
const rollbackFont = this.document._fontSource;
const rollbackFontSize = this.document._fontSize;
const rollbackFontFamily = this.document._fontFamily;
if (cell.font?.src) this.document.font(cell.font.src, cell.font?.family);
if (cell.font?.size) this.document.fontSize(cell.font.size);
const unRotatedTextBounds = this.document.boundsOfString(cell.text, 0, 0, {
...textOptions,
rotation: 0
});
textOptions.width = unRotatedTextBounds.width;
textOptions.height = unRotatedTextBounds.height;
textBounds = this.document.boundsOfString(cell.text, 0, 0, textOptions);
this.document.font(rollbackFont, rollbackFontFamily, rollbackFontSize);
}
return {
...cell,
textOptions,
x: this._columnXPos[cell.colIndex],
y: this._rowYPos[cell.rowIndex],
textX: this._columnXPos[cell.colIndex] + cell.padding.left,
textY: this._rowYPos[cell.rowIndex] + cell.padding.top,
width: cellWidth,
height: cellHeight,
textAllocatedHeight,
textAllocatedWidth,
textBounds
};
}
function computeBounds(rotation, allocWidth, allocHeight) {
let textMaxWidth, textMaxHeight;
const cos = cosine(rotation);
const sin = sine(rotation);
if (rotation === 0 || rotation === 180) {
textMaxWidth = allocWidth;
textMaxHeight = allocHeight;
} else if (rotation === 90 || rotation === 270) {
textMaxWidth = allocHeight;
textMaxHeight = allocWidth;
} else if (rotation < 90 || rotation > 180 && rotation < 270) {
textMaxWidth = allocWidth / (2 * cos);
textMaxHeight = allocWidth / (2 * sin);
} else {
textMaxHeight = allocWidth / (2 * cos);
textMaxWidth = allocWidth / (2 * sin);
}
const EF = sin * textMaxWidth;
const FG = cos * textMaxHeight;
if (EF + FG > allocHeight) {
const denominator = cos * cos - sin * sin;
if (rotation === 0 || rotation === 180) {
textMaxWidth = allocWidth;
textMaxHeight = allocHeight;
} else if (rotation === 90 || rotation === 270) {
textMaxWidth = allocHeight;
textMaxHeight = allocWidth;
} else if (rotation < 90 || rotation > 180 && rotation < 270) {
textMaxWidth = (allocWidth * cos - allocHeight * sin) / denominator;
textMaxHeight = (allocHeight * cos - allocWidth * sin) / denominator;
} else {
textMaxHeight = (allocWidth * cos - allocHeight * sin) / denominator;
textMaxWidth = (allocHeight * cos - allocWidth * sin) / denominator;
}
}
return {
width: Math.abs(textMaxWidth),
height: Math.abs(textMaxHeight)
};
}
function accommodateTable() {
const structParent = this.opts.structParent;
if (structParent) {
this._tableStruct = this.document.struct('Table');
this._tableStruct.dictionary.data.ID = this._id;
if (structParent instanceof PDFStructureElement) {
structParent.add(this._tableStruct);
} else if (structParent instanceof PDFDocument) {
structParent.addStructure(this._tableStruct);
}
this._headerRowLookup = {};
this._headerColumnLookup = {};
}
}
function accommodateCleanup() {
if (this._tableStruct) this._tableStruct.end();
}
function accessibleRow(row, rowIndex, renderCell) {
const rowStruct = this.document.struct('TR');
rowStruct.dictionary.data.ID = new String(`${this._id}-${rowIndex}`);
this._tableStruct.add(rowStruct);
row.forEach(cell => renderCell(cell, rowStruct));
rowStruct.end();
}
function accessibleCell(cell, rowStruct, callback) {
const doc = this.document;
const cellStruct = doc.struct(cell.type, {
title: cell.title
});
cellStruct.dictionary.data.ID = cell.id;
rowStruct.add(cellStruct);
const padding = cell.padding;
const border = cell.border;
const attributes = {
O: 'Table',
Width: cell.width,
Height: cell.height,
Padding: [padding.top, padding.bottom, padding.left, padding.right],
RowSpan: cell.rowSpan > 1 ? cell.rowSpan : undefined,
ColSpan: cell.colSpan > 1 ? cell.colSpan : undefined,
BorderThickness: [border.top, border.bottom, border.left, border.right]
};
if (cell.type === 'TH') {
if (cell.scope === 'Row' || cell.scope === 'Both') {
for (let i = 0; i < cell.rowSpan; i++) {
if (!this._headerRowLookup[cell.rowIndex + i]) {
this._headerRowLookup[cell.rowIndex + i] = [];
}
this._headerRowLookup[cell.rowIndex + i].push(cell.id);
}
attributes.Scope = cell.scope;
}
if (cell.scope === 'Column' || cell.scope === 'Both') {
for (let i = 0; i < cell.colSpan; i++) {
if (!this._headerColumnLookup[cell.colIndex + i]) {
this._headerColumnLookup[cell.colIndex + i] = [];
}
this._headerColumnLookup[cell.colIndex + i].push(cell.id);
}
attributes.Scope = cell.scope;
}
}
const Headers = new Set([...Array.from({
length: cell.colSpan
}, (_, i) => this._headerColumnLookup[cell.colIndex + i]).flat(), ...Array.from({
length: cell.rowSpan
}, (_, i) => this._headerRowLookup[cell.rowIndex + i]).flat()].filter(Boolean));
if (Headers.size) attributes.Headers = Array.from(Headers);
const normalizeColor = doc._normalizeColor;
if (cell.backgroundColor != null) {
attributes.BackgroundColor = normalizeColor(cell.backgroundColor);
}
const hasBorder = [border.top, border.bottom, border.left, border.right];
if (hasBorder.some(x => x)) {
const borderColor = cell.borderColor;
attributes.BorderColor = [hasBorder[0] ? normalizeColor(borderColor.top) : null, hasBorder[1] ? normalizeColor(borderColor.bottom) : null, hasBorder[2] ? normalizeColor(borderColor.left) : null, hasBorder[3] ? normalizeColor(borderColor.right) : null];
}
Object.keys(attributes).forEach(key => attributes[key] === undefined && delete attributes[key]);
cellStruct.dictionary.data.A = doc.ref(attributes);
cellStruct.add(callback);
cellStruct.end();
cellStruct.dictionary.data.A.end();
}
function renderRow(row, rowIndex) {
if (this._tableStruct) {
accessibleRow.call(this, row, rowIndex, renderCell.bind(this));
} else {
row.forEach(cell => renderCell.call(this, cell));
}
return this._rowYPos[rowIndex] + this._rowHeights[rowIndex];
}
function renderCell(cell, rowStruct) {
const cellRenderer = () => {
if (cell.backgroundColor != null) {
this.document.save().fillColor(cell.backgroundColor).rect(cell.x, cell.y, cell.width, cell.height).fill().restore();
}
renderBorder.call(this, cell.border, cell.borderColor, cell.x, cell.y, cell.width, cell.height);
if (cell.debug) {
this.document.save();
this.document.dash(1, {
space: 1
}).lineWidth(1).strokeOpacity(0.3);
this.document.rect(cell.x, cell.y, cell.width, cell.height).stroke('green');
this.document.restore();
}
if (cell.text) renderCellText.call(this, cell);
};
if (rowStruct) accessibleCell.call(this, cell, rowStruct, cellRenderer);else cellRenderer();
}
function renderCellText(cell) {
const doc = this.document;
const rollbackFont = doc._fontSource;
const rollbackFontSize = doc._fontSize;
const rollbackFontFamily = doc._fontFamily;
if (cell.customFont) {
if (cell.font.src) doc.font(cell.font.src, cell.font.family);
if (cell.font.size) doc.fontSize(cell.font.size);
}
const x = cell.textX;
const y = cell.textY;
const Ah = cell.textAllocatedHeight;
const Aw = cell.textAllocatedWidth;
const Cw = cell.textBounds.width;
const Ch = cell.textBounds.height;
const Ox = -cell.textBounds.x;
const Oy = -cell.textBounds.y;
const PxScale = cell.align.x === 'right' ? 1 : cell.align.x === 'center' ? 0.5 : 0;
const Px = (Aw - Cw) * PxScale;
const PyScale = cell.align.y === 'bottom' ? 1 : cell.align.y === 'center' ? 0.5 : 0;
const Py = (Ah - Ch) * PyScale;
const dx = Px + Ox;
const dy = Py + Oy;
if (cell.debug) {
doc.save();
doc.dash(1, {
space: 1
}).lineWidth(1).strokeOpacity(0.3);
if (cell.text) {
doc.moveTo(x + Px, y).lineTo(x + Px, y + Ah).moveTo(x + Px + Cw, y).lineTo(x + Px + Cw, y + Ah).stroke('blue').moveTo(x, y + Py).lineTo(x + Aw, y + Py).moveTo(x, y + Py + Ch).lineTo(x + Aw, y + Py + Ch).stroke('green');
}
doc.rect(x, y, Aw, Ah).stroke('orange');
doc.restore();
}
doc.save().rect(x, y, Aw, Ah).clip();
doc.fillColor(cell.textColor).strokeColor(cell.textStrokeColor);
if (cell.textStroke > 0) doc.lineWidth(cell.textStroke);
doc.text(cell.text, x + dx, y + dy, cell.textOptions);
doc.restore();
if (cell.font) doc.font(rollbackFont, rollbackFontFamily, rollbackFontSize);
}
function renderBorder(border, borderColor, x, y, width, height, mask) {
border = Object.fromEntries(Object.entries(border).map(([k, v]) => [k, mask && !mask[k] ? 0 : v]));
const doc = this.document;
if ([border.right, border.bottom, border.left].every(val => val === border.top)) {
if (border.top > 0) {
doc.save().lineWidth(border.top).strokeColor(borderColor.top).rect(x, y, width, height).stroke().restore();
}
} else {
if (border.top > 0) {
doc.save().lineWidth(border.top).moveTo(x, y).strokeColor(borderColor.top).lineTo(x + width, y).stroke().restore();
}
if (border.right > 0) {
doc.save().lineWidth(border.right).moveTo(x + width, y).strokeColor(borderColor.right).lineTo(x + width, y + height).stroke().restore();
}
if (border.bottom > 0) {
doc.save().lineWidth(border.bottom).moveTo(x + width, y + height).strokeColor(borderColor.bottom).lineTo(x, y + height).stroke().restore();
}
if (border.left > 0) {
doc.save().lineWidth(border.left).moveTo(x, y + height).strokeColor(borderColor.left).lineTo(x, y).stroke().restore();
}
}
}
class PDFTable {
constructor(document, opts = {}) {
this.document = document;
this.opts = Object.freeze(opts);
normalizeTable.call(this);
accommodateTable.call(this);
this._currRowIndex = 0;
this._ended = false;
if (opts.data) {
for (const row of opts.data) this.row(row);
return this.end();
}
}
row(row, lastRow = false) {
if (this._ended) {
throw new Error(`Table was marked as ended on row ${this._currRowIndex}`);
}
row = Array.from(row);
row = normalizeRow.call(this, row, this._currRowIndex);
if (this._currRowIndex === 0) ensure.call(this, row);
const {
newPage,
toRender
} = measure.call(this, row, this._currRowIndex);
if (newPage) this.document.continueOnNewPage();
const yPos = renderRow.call(this, toRender, this._currRowIndex);
this.document.x = this._position.x;
this.document.y = yPos;
if (lastRow) return this.end();
this._currRowIndex++;
return this;
}
end() {
while (this._rowBuffer?.size) this.row([]);
this._ended = true;
accommodateCleanup.call(this);
return this.document;
}
}
var TableMixin = {
initTables() {
this._tableIndex = 0;
},
table(opts) {
return new PDFTable(this, opts);
}
};
class PDFMetadata {
constructor() {
this._metadata = `
<?xpacket begin="\ufeff" id="W5M0MpCehiHzreSzNTczkc9d"?>
<x:xmpmeta xmlns:x="adobe:ns:meta/">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
`;
}
_closeTags() {
this._metadata = this._metadata.concat(`
</rdf:RDF>
</x:xmpmeta>
<?xpacket end="w"?>
`);
}
append(xml, newline = true) {
this._metadata = this._metadata.concat(xml);
if (newline) this._metadata = this._metadata.concat('\n');
}
getXML() {
return this._metadata;
}
getLength() {
return this._metadata.length;
}
end() {
this._closeTags();
this._metadata = this._metadata.trim();
}
}
var MetadataMixin = {
initMetadata() {
this.metadata = new PDFMetadata();
},
appendXML(xml, newline = true) {
this.metadata.append(xml, newline);
},
_addInfo() {
this.appendXML(`
<rdf:Description rdf:about="" xmlns:xmp="http://ns.adobe.com/xap/1.0/">
<xmp:CreateDate>${this.info.CreationDate.toISOString().split('.')[0] + 'Z'}</xmp:CreateDate>
<xmp:CreatorTool>${this.info.Creator}</xmp:CreatorTool>
</rdf:Description>
`);
if (this.info.Title || this.info.Author || this.info.Subject) {
this.appendXML(`
<rdf:Description rdf:about="" xmlns:dc="http://purl.org/dc/elements/1.1/">
`);
if (this.info.Title) {
this.appendXML(`
<dc:title>
<rdf:Alt>
<rdf:li xml:lang="x-default">${this.info.Title}</rdf:li>
</rdf:Alt>
</dc:title>
`);
}
if (this.info.Author) {
this.appendXML(`
<dc:creator>
<rdf:Seq>
<rdf:li>${this.info.Author}</rdf:li>
</rdf:Seq>
</dc:creator>
`);
}
if (this.info.Subject) {
this.appendXML(`
<dc:description>
<rdf:Alt>
<rdf:li xml:lang="x-default">${this.info.Subject}</rdf:li>
</rdf:Alt>
</dc:description>
`);
}
this.appendXML(`
</rdf:Description>
`);
}
this.appendXML(`
<rdf:Description rdf:about="" xmlns:pdf="http://ns.adobe.com/pdf/1.3/">
<pdf:Producer>${this.info.Producer}</pdf:Producer>`, false);
if (this.info.Keywords) {
this.appendXML(`
<pdf:Keywords>${this.info.Keywords}</pdf:Keywords>`, false);
}
this.appendXML(`
</rdf:Description>
`);
},
endMetadata() {
this._addInfo();
this.metadata.end();
if (this.version != 1.3) {
this.metadataRef = this.ref({
length: this.metadata.getLength(),
Type: 'Metadata',
Subtype: 'XML'
});
this.metadataRef.compress = false;
this.metadataRef.write(new TextEncoder().encode(this.metadata.getXML()));
this.metadataRef.end();
this._root.data.Metadata = this.metadataRef;
}
}
};
class PDFDocument extends Readable {
constructor(options = {}) {
super(options);
this.options = options;
switch (options.pdfVersion) {
case '1.4':
this.version = 1.4;
break;
case '1.5':
this.version = 1.5;
break;
case '1.6':
this.version = 1.6;
break;
case '1.7':
case '1.7ext3':
this.version = 1.7;
break;
default:
this.version = 1.3;
break;
}
this.compress = this.options.compress != null ? this.options.compress : true;
this._pageBuffer = [];
this._pageBufferStart = 0;
this._offsets = [];
this._waiting = 0;
this._ended = false;
this._offset = 0;
const Pages = this.ref({
Type: 'Pages',
Count: 0,
Kids: []
});
const Names = this.ref({
Dests: new PDFNameTree()
});
this._root = this.ref({
Type: 'Catalog',
Pages,
Names
});
if (this.options.lang) {
this._root.data.Lang = new String(this.options.lang);
}
if (this.options.pageLayout) {
const layout = this.options.pageLayout;
this._root.data.PageLayout = layout.charAt(0).toUpperCase() + layout.slice(1);
}
this.page = null;
this.initMetadata();
this.initColor();
this.initVector();
this.initFonts(options.font);
this.initText();
this.initImages();
this.initOutline();
this.initMarkings(options);
this.initTables();
this.initSubset(options);
this.info = {
Producer: 'PDFKit',
Creator: 'PDFKit',
CreationDate: new Date()
};
if (this.options.info) {
for (let key in this.options.info) {
const val = this.options.info[key];
this.info[key] = val;
}
}
if (this.options.displayTitle) {
this._root.data.ViewerPreferences = this.ref({
DisplayDocTitle: true
});
}
this._id = PDFSecurity.generateFileID(this.info);
this._security = PDFSecurity.create(this, options);
this._write(`%PDF-${this.version}`);
this._write('%\xFF\xFF\xFF\xFF');
if (this.options.autoFirstPage !== false) {
this.addPage();
}
}
addPage(options) {
const documentOptions = this.options;
if (!documentOptions.bufferPages) {
this.flushPages();
}
const font = options?.font;
if (font) {
this.font(font, options.fontFamily);
}
const fontSize = options?.fontSize;
if (fontSize) this.fontSize(fontSize);
this.page = new PDFPage(this, options || documentOptions);
this._pageBuffer.push(this.page);
const pages = this._root.data.Pages.data;
pages.Kids.push(this.page.dictionary);
pages.Count++;
this.x = this.page.margins.left;
this.y = this.page.margins.top;
this._ctm = [1, 0, 0, 1, 0, 0];
this.transform(1, 0, 0, -1, 0, this.page.height);
this.emit('pageAdded');
return this;
}
continueOnNewPage(options) {
const pageMarkings = this.endPageMarkings(this.page);
this.addPage(options ?? this.page._options);
this.initPageMarkings(pageMarkings);
return this;
}
bufferedPageRange() {
return {
start: this._pageBufferStart,
count: this._pageBuffer.length
};
}
switchToPage(n) {
let page;
if (!(page = this._pageBuffer[n - this._pageBufferStart])) {
throw new Error(`switchToPage(${n}) out of bounds, current buffer covers pages ${this._pageBufferStart} to ${this._pageBufferStart + this._pageBuffer.length - 1}`);
}
return this.page = page;
}
flushPages() {
const pages = this._pageBuffer;
this._pageBuffer = [];
this._pageBufferStart += pages.length;
for (let page of pages) {
this.endPageMarkings(page);
page.end();
}
}
addNamedDestination(name, ...args) {
if (args.length === 0) {
args = ['XYZ', null, null, null];
}
if (args[0] === 'XYZ' && args[2] !== null) {
args[2] = this.page.height - args[2];
}
args.unshift(this.page.dictionary);
this._root.data.Names.data.Dests.add(name, args);
}
addNamedEmbeddedFile(name, ref) {
if (!ref) {
throw new Error(`No ref specified for embedded file ${name}`);
}
if (!this._root.data.Names.data.EmbeddedFiles) {
this._root.data.Names.data.EmbeddedFiles = new PDFNameTree({
limits: false
});
}
this._root.data.Names.data.EmbeddedFiles.add(name, ref);
}
addNamedJavaScript(name, js) {
if (!this._root.data.Names.data.JavaScript) {
this._root.data.Names.data.JavaScript = new PDFNameTree();
}
let data = {
JS: new String(js),
S: 'JavaScript'
};
this._root.data.Names.data.JavaScript.add(name, data);
}
ref(data) {
const ref = new PDFReference(this, this._offsets.length + 1, data);
this._offsets.push(null);
this._waiting++;
return ref;
}
_read() {}
_write(data) {
if (!(data instanceof Uint8Array)) {
data = fromBinaryString(data + '\n');
}
this.push(data);
this._offset += data.length;
}
addContent(data) {
this.page.write(data);
return this;
}
_refEnd(ref) {
this._offsets[ref.id - 1] = ref.offset;
if (--this._waiting === 0 && this._ended) {
this._finalize();
this._ended = false;
}
}
end() {
this.flushPages();
this._info = this.ref();
for (let key in this.info) {
let val = this.info[key];
if (typeof val === 'string') {
val = new String(val);
}
let entry = this.ref(val);
entry.end();
this._info.data[key] = entry;
}
this._info.end();
for (let name in this._fontFamilies) {
const font = this._fontFamilies[name];
font.finalize();
}
this.endOutline();
this.endMarkings();
if (this.subset) {
this.endSubset();
}
this.endMetadata();
this._root.end();
this._root.data.Pages.end();
this._root.data.Names.end();
this.endAcroForm();
if (this._root.data.ViewerPreferences) {
this._root.data.ViewerPreferences.end();
}
if (this._security) {
this._security.end();
}
if (this._waiting === 0) {
this._finalize();
} else {
this._ended = true;
}
}
_finalize() {
const xRefOffset = this._offset;
this._write('xref');
this._write(`0 ${this._offsets.length + 1}`);
this._write('0000000000 65535 f ');
for (let offset of this._offsets) {
offset = `0000000000${offset}`.slice(-10);
this._write(offset + ' 00000 n ');
}
const trailer = {
Size: this._offsets.length + 1,
Root: this._root,
Info: this._info,
ID: [this._id, this._id]
};
if (this._security) {
trailer.Encrypt = this._security.dictionary;
}
this._write('trailer');
this._write(PDFObject.convert(trailer));
this._write('startxref');
this._write(`${xRefOffset}`);
this._write('%%EOF');
this.push(null);
}
toString() {
return '[object PDFDocument]';
}
}
const mixin = methods => {
Object.assign(PDFDocument.prototype, methods);
};
mixin(MetadataMixin);
mixin(ColorMixin);
mixin(VectorMixin);
mixin(FontsMixin);
mixin(TextMixin);
mixin(ImagesMixin);
mixin(AnnotationsMixin);
mixin(OutlineMixin);
mixin(MarkingsMixin);
mixin(AcroFormMixin);
mixin(AttachmentsMixin);
mixin(SubsetMixin);
mixin(TableMixin);
var iccProfileBase64 = "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";
registerFile(ICC_PROFILE_PATH, fromBase64(iccProfileBase64));
var glyphNames = 'space exclam quotedbl numbersign dollar percent ampersand quotesingle parenleft parenright asterisk plus comma hyphen period slash zero one two three four five six seven eight nine colon semicolon less equal greater question at A B C D E F G H I J K L M N O P Q R S T U V W X Y Z bracketleft backslash bracketright asciicircum underscore grave a b c d e f g h i j k l m n o p q r s t u v w x y z braceleft bar braceright asciitilde Euro quotesinglbase florin quotedblbase ellipsis dagger daggerdbl circumflex perthousand Scaron guilsinglleft OE Zcaron quoteleft quoteright quotedblleft quotedblright bullet endash emdash tilde trademark scaron guilsinglright oe zcaron ydieresis exclamdown cent sterling currency yen brokenbar section dieresis copyright ordfeminine guillemotleft logicalnot registered macron degree plusminus twosuperior threesuperior acute mu paragraph periodcentered cedilla onesuperior ordmasculine guillemotright onequarter onehalf threequarters questiondown Agrave Aacute Acircumflex Atilde Adieresis Aring AE Ccedilla Egrave Eacute Ecircumflex Edieresis Igrave Iacute Icircumflex Idieresis Eth Ntilde Ograve Oacute Ocircumflex Otilde Odieresis multiply Oslash Ugrave Uacute Ucircumflex Udieresis Yacute Thorn germandbls agrave aacute acircumflex atilde adieresis aring ae ccedilla egrave eacute ecircumflex edieresis igrave iacute icircumflex idieresis eth ntilde ograve oacute ocircumflex otilde odieresis divide oslash ugrave uacute ucircumflex udieresis yacute thorn';
var Courier = {
name: 'Courier',
bbox: [-23, -250, 715, 805],
ascender: 629,
descender: -157,
xHeight: 426,
capHeight: 562,
glyphNames,
glyphWidths: [600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600],
kernPairs: []
};
var CourierBold = {
name: 'Courier-Bold',
bbox: [-113, -250, 749, 801],
ascender: 629,
descender: -157,
xHeight: 439,
capHeight: 562,
glyphNames,
glyphWidths: [600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600],
kernPairs: []
};
var CourierBoldOblique = {
name: 'Courier-BoldOblique',
bbox: [-57, -250, 869, 801],
ascender: 629,
descender: -157,
xHeight: 439,
capHeight: 562,
glyphNames,
glyphWidths: [600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600],
kernPairs: []
};
var CourierOblique = {
name: 'Courier-Oblique',
bbox: [-27, -250, 849, 805],
ascender: 629,
descender: -157,
xHeight: 426,
capHeight: 562,
glyphNames,
glyphWidths: [600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600, 600],
kernPairs: []
};
var Helvetica = {
name: 'Helvetica',
bbox: [-166, -225, 1000, 931],
ascender: 718,
descender: -207,
xHeight: 523,
capHeight: 718,
glyphNames,
glyphWidths: [278, 278, 355, 556, 556, 889, 667, 191, 333, 333, 389, 584, 278, 333, 278, 278, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 278, 278, 584, 584, 584, 556, 1015, 667, 667, 722, 722, 667, 611, 778, 722, 278, 500, 667, 556, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 278, 278, 278, 469, 556, 333, 556, 556, 500, 556, 556, 278, 556, 556, 222, 222, 500, 222, 833, 556, 556, 556, 556, 333, 500, 278, 556, 500, 722, 500, 500, 500, 334, 260, 334, 584, 556, 222, 556, 333, 1000, 556, 556, 333, 1000, 667, 333, 1000, 611, 222, 222, 333, 333, 350, 556, 1000, 333, 1000, 500, 333, 944, 500, 500, 333, 556, 556, 556, 556, 260, 556, 333, 737, 370, 556, 584, 737, 333, 400, 584, 333, 333, 333, 556, 537, 278, 333, 333, 365, 556, 834, 834, 834, 611, 667, 667, 667, 667, 667, 667, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278, 722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611, 556, 556, 556, 556, 556, 556, 889, 500, 556, 556, 556, 556, 278, 278, 278, 278, 556, 556, 556, 556, 556, 556, 556, 584, 611, 556, 556, 556, 556, 500, 556],
kernPairs: [-180, [10332, 2], -160, [9569], -150, [8182, 2], -140, [9517, 54, 70, 1552, 1074, 1, 1, 51, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 26464, 1, 1, 51, 4, 10, 105, 1, 1, 2, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2], -125, [11622, 2], -120, [7147, 3206, 119, 1, 1, 1, 1, 1, 715, 2, 19, 32, 4, 10, 3, 3, 2, 2, 63, 1, 1, 1, 1, 1, 27, 1, 1, 2, 1, 4, 1, 1, 7, 1, 1, 2, 2, 1, 1, 1, 1, 1, 21339, 215, 215, 215, 215, 215], -110, [9512, 2, 2774, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1, 26481, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1], -100, [2689, 2, 428, 2, 4031, 124, 11871, 2, 6878, 2, 6708, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124, 11871, 2], -95, [44732, 2], -90, [57, 124, 7616, 124], -85, [12302, 123, 1, 1, 1, 1, 2, 26531, 123, 1, 1, 1, 1, 2, 5717], -80, [8203, 119, 1, 1, 1, 1, 1, 3296, 20, 36, 10, 73, 1, 1, 1, 1, 1, 35, 1, 1, 1, 7, 1, 1, 1, 1, 2, 19, 2, 6663, 2], -70, [7149, 603, 2, 40, 1721, 647, 124, 1389, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1, 11613, 9299, 215, 215, 215, 215, 215, 2798, 124, 91, 124, 91, 124, 91, 124, 91, 124, 306, 124, 1081, 5704, 1, 2, 32, 92], -60, [108, 2902, 7151, 1140, 66, 5, 13, 896, 1, 6435, 2, 17887, 215, 215, 215, 215, 430, 1045, 1], -57, [23328, 216], -55, [44785, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 27, 3, 64, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1], -50, [52, 2, 5536, 215, 1343, 2, 122, 1, 1, 1, 960, 119, 1, 1, 1, 1, 1, 933, 42, 32, 49, 1, 1, 1, 1, 2, 37, 701, 230, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 276, 3, 124, 927, 119, 1, 1, 1, 1, 1, 5660, 2, 5859, 14, 1, 34, 9181, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 2669, 215, 215, 215, 215, 430], -45, [8252], -40, [55, 7126, 1, 2, 32, 92, 465, 22, 97, 1, 1, 1, 1, 1, 1417, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 664, 2, 38, 228, 119, 1, 1, 1, 1, 1, 294, 124, 1, 1, 1, 297, 123, 1, 1, 1, 1, 2, 51, 2, 19, 119, 1, 1, 1, 1, 1, 84, 1, 12, 8, 123, 1, 1, 1, 1, 2, 52, 52, 119, 1, 1, 1, 1, 1, 2188, 2, 2793, 2, 6866, 8901, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 2594, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 390, 2, 38, 175, 2, 19, 119, 1, 1, 1, 1, 1, 70, 2, 19, 119, 1, 1, 1, 1, 1, 70, 2, 19, 119, 1, 1, 1, 1, 1, 70, 2, 19, 119, 1, 1, 1, 1, 1, 4585, 2, 213, 2, 213, 2, 213, 2, 213, 2], -35, [17212, 2], -30, [110, 7020, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 230, 2, 700, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 664, 2, 286, 124, 1, 1, 1, 92, 32, 92, 487, 642, 3, 1089, 10, 6, 107, 1, 1, 1, 7, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2027, 32, 92, 733, 2, 139, 2, 51, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 311, 32, 92, 1380, 1, 32, 92, 91, 32, 92, 519, 1057, 123, 1, 1, 1, 6127, 7473, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 230, 2, 2406, 215, 215, 215, 215, 430, 1754, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 518, 2, 213, 2, 213, 2, 213, 2, 1505, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92], -25, [18555, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2], -20, [7322, 2, 1739, 32, 20, 67, 1, 1, 1, 1, 1, 27, 1, 1, 1, 1, 1, 20, 1, 1, 1, 896, 119, 1, 1, 1, 1, 1, 535, 123, 1, 1, 1, 1, 2, 51, 2, 227, 1, 665, 42, 32, 49, 1, 1, 1, 1, 2, 37, 290, 124, 1609, 1, 204, 9, 1, 3, 32, 88, 1, 1, 1, 1, 77, 442, 2, 32, 92, 1146, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 523, 2344, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 3029, 2, 3706, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 10360, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 306, 119, 1, 1, 1, 1, 1, 991, 124, 534, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 418, 227, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 1163, 2559, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2], -15, [14417, 430, 2, 1795, 32, 92, 91, 32, 92, 88, 1, 785, 2, 911, 119, 1, 1, 1, 1, 1, 525, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 5609, 2, 700, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 15069, 215, 2, 213, 2, 213, 2, 213, 2, 1365, 32, 92, 88, 1, 214, 1, 214, 1, 214, 1, 214, 1], -10, [7363, 124, 1, 1, 1, 3098, 124, 1, 1, 1, 3541, 1091, 1293, 124, 1, 1, 1, 88, 124, 1, 1, 1, 713, 119, 1, 1, 1, 1, 1, 955, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 24387, 124, 1, 1, 1], 15, [17703, 2, 1, 9, 111, 1, 1, 1, 10, 1, 1, 1], 25, [17707, 1, 123], 30, [17656, 1, 53, 6, 3, 32, 92], 40, [17714], 50, [15159], 60, [15161]]
};
var HelveticaBold = {
name: 'Helvetica-Bold',
bbox: [-170, -228, 1003, 962],
ascender: 718,
descender: -207,
xHeight: 532,
capHeight: 718,
glyphNames,
glyphWidths: [278, 333, 474, 556, 556, 889, 722, 238, 333, 333, 389, 584, 278, 333, 278, 278, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 333, 333, 584, 584, 584, 611, 975, 722, 722, 722, 722, 667, 611, 778, 722, 278, 556, 722, 611, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 333, 278, 333, 584, 556, 333, 556, 611, 556, 611, 556, 333, 611, 611, 278, 278, 556, 278, 889, 611, 611, 611, 611, 389, 556, 333, 611, 556, 778, 556, 556, 500, 389, 280, 389, 584, 556, 278, 556, 500, 1000, 556, 556, 333, 1000, 667, 333, 1000, 611, 278, 278, 500, 500, 350, 556, 1000, 333, 1000, 556, 333, 944, 500, 556, 333, 556, 556, 556, 556, 280, 556, 333, 737, 370, 556, 584, 737, 333, 400, 584, 333, 333, 333, 611, 556, 278, 333, 333, 365, 556, 834, 834, 834, 611, 722, 722, 722, 722, 722, 722, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278, 722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611, 556, 556, 556, 556, 556, 556, 889, 556, 556, 556, 556, 556, 278, 278, 278, 278, 611, 611, 611, 611, 611, 611, 611, 584, 611, 611, 611, 611, 611, 556, 611],
kernPairs: [-140, [9569, 2], -120, [57, 124, 2508, 2, 428, 2, 6396, 124, 691, 2, 859, 429, 2], -110, [7152, 124, 2238, 2774, 119, 1, 1, 1, 1, 1, 20325, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124, 5012, 119, 1, 1, 1, 1, 1], -100, [52, 8130, 2, 2169, 119, 1, 1, 1, 1, 1, 1790, 2, 65, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 26460, 2, 65, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1], -90, [7147, 2365, 1701, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1, 297, 123, 1, 1, 1, 1, 2, 502, 119, 1, 1, 1, 1, 1, 20288, 215, 215, 215, 215, 215, 5173, 119, 1, 1, 1, 1, 1], -80, [54, 1, 55, 7039, 1054, 119, 1, 1, 1, 1, 1, 1188, 1677, 2, 51, 14, 3, 102, 1, 1, 1, 1, 1, 13, 1, 1, 1, 1, 2, 235, 20, 119, 1, 1, 1, 1, 1, 70, 2, 485, 123, 1, 1, 1, 6052, 2, 643, 2, 4286, 68, 362, 2162, 2, 6705, 215, 215, 215, 215, 215, 5175, 123, 1, 1, 1, 6697, 2], -70, [7797, 124, 2241, 124, 2016, 123, 1, 1, 1, 1, 2, 24176, 124, 91, 124, 91, 124, 91, 124, 91, 124, 306, 124, 941, 123, 1, 1, 1, 1, 2], -60, [108, 7042, 4099, 18, 2, 32, 71, 1, 1, 1, 18, 282, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1, 36, 46, 73, 1, 1, 1, 1, 1, 45, 1, 1, 1, 1, 2, 5609, 2, 5874, 34, 9183, 215, 215, 215, 215, 215], -50, [7134, 14, 124, 1, 1, 1, 2863, 21, 1, 1, 96, 1, 1, 1, 1, 1, 542, 3, 124, 497, 119, 1, 1, 1, 1, 1, 97, 8, 22, 101, 1, 1, 1, 1, 2, 16, 1, 1, 1, 476, 1, 20437, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 2648, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 306, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 84, 1], -46, [23328, 216], -45, [11910, 124, 1, 1, 1], -40, [2580, 430, 2580, 215, 1325, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 502, 21, 1, 97, 1, 1, 1, 1, 1, 1437, 32, 92, 659, 2, 38, 242, 123, 1, 1, 1, 1, 2, 277, 401, 1, 20, 123, 1, 1, 1, 1, 2, 280, 1, 201, 52, 119, 1, 1, 1, 1, 1, 4842, 1861, 2, 4798, 9198, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 2631, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 390, 2, 38, 5409], -35, [9324, 123, 1, 1, 1, 1, 2, 2441, 123, 1, 1, 1], -30, [7180, 2, 2, 32, 88, 1, 1, 1, 1, 35, 119, 1, 1, 1, 1, 1, 285, 2, 1538, 38, 85, 1, 1, 1, 1, 2, 33, 1, 1, 1, 92, 32, 92, 712, 4, 115, 1, 1, 1, 1, 1, 3, 1, 1, 1, 892, 2, 5235, 32, 92, 305, 1496, 123, 1, 1, 1, 1, 2, 502, 119, 1, 1, 1, 1, 1, 6756, 119, 1, 1, 1, 1, 1, 6561, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 4099, 2, 213, 2, 213, 2, 213, 2, 4804, 215, 215, 215, 215, 430, 1052, 119, 1, 1, 1, 1, 1], -25, [19214, 123, 1, 1, 1, 1, 2, 6751, 123, 1, 1, 1, 1, 2, 19651, 123, 1, 1, 1, 1, 2], -20, [8235, 119, 1, 1, 1, 1, 1, 683, 2, 19, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1, 1555, 5, 1, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 942, 42, 32, 49, 1, 1, 1, 1, 2, 37, 2026, 32, 92, 87, 1, 3, 32, 88, 1, 1, 1, 1, 77, 1, 648, 123, 1, 1, 1, 1, 2, 311, 32, 92, 947, 124, 1, 1, 1, 92, 32, 92, 88, 3, 32, 92, 445, 54, 1, 11, 2, 110, 11, 1, 1, 1, 1, 2, 717, 119, 1, 1, 1, 1, 1, 105, 123, 1, 1, 1, 1, 2, 4598, 10, 16128, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 292, 1, 2163, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 303, 3, 32, 92], -15, [9314, 123, 1, 1, 1, 4621, 1, 644, 1, 2, 32, 92, 88, 1, 1, 1, 32, 92, 1156, 123, 1, 1, 1, 1, 2, 94, 2, 32, 92, 519, 217, 32, 92, 288, 12, 34, 185, 7310, 14404, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 644, 1, 1, 1, 32, 92, 88, 1, 1, 1, 32, 92, 88, 1, 1, 1, 32, 92, 88, 1, 1, 1, 32, 92, 1379, 215, 215, 215, 215, 430], -10, [7363, 124, 1, 1, 1, 3098, 124, 1, 1, 1, 1136, 1, 2194, 220, 211, 17, 32, 92, 70, 374, 2, 55, 123, 1, 1, 1, 91, 1519, 124, 1, 1, 1, 2007, 123, 1, 1, 1, 89, 123, 1, 1, 1, 6754, 123, 1, 1, 1, 13421, 215, 215, 215, 215, 215, 431, 17, 32, 92, 2022, 124, 1, 1, 1, 2437, 123, 1, 1, 1], 10, [14847, 487, 123, 1, 1, 1, 2256, 3, 32, 92, 1576, 123, 1, 1, 1, 6324, 123, 1, 1, 1, 15297, 215, 215, 215], 20, [10547, 2, 4300, 2865, 23580, 215, 215, 215], 30, [15159, 2]]
};
var HelveticaBoldOblique = {
name: 'Helvetica-BoldOblique',
bbox: [-174, -228, 1114, 962],
ascender: 718,
descender: -207,
xHeight: 532,
capHeight: 718,
glyphNames,
glyphWidths: [278, 333, 474, 556, 556, 889, 722, 238, 333, 333, 389, 584, 278, 333, 278, 278, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 333, 333, 584, 584, 584, 611, 975, 722, 722, 722, 722, 667, 611, 778, 722, 278, 556, 722, 611, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 333, 278, 333, 584, 556, 333, 556, 611, 556, 611, 556, 333, 611, 611, 278, 278, 556, 278, 889, 611, 611, 611, 611, 389, 556, 333, 611, 556, 778, 556, 556, 500, 389, 280, 389, 584, 556, 278, 556, 500, 1000, 556, 556, 333, 1000, 667, 333, 1000, 611, 278, 278, 500, 500, 350, 556, 1000, 333, 1000, 556, 333, 944, 500, 556, 333, 556, 556, 556, 556, 280, 556, 333, 737, 370, 556, 584, 737, 333, 400, 584, 333, 333, 333, 611, 556, 278, 333, 333, 365, 556, 834, 834, 834, 611, 722, 722, 722, 722, 722, 722, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278, 722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611, 556, 556, 556, 556, 556, 556, 889, 556, 556, 556, 556, 556, 278, 278, 278, 278, 611, 611, 611, 611, 611, 611, 611, 584, 611, 611, 611, 611, 611, 556, 611],
kernPairs: [-140, [9569, 2], -120, [57, 124, 2508, 2, 428, 2, 6396, 124, 691, 2, 859, 429, 2], -110, [7152, 124, 2238, 2774, 119, 1, 1, 1, 1, 1, 20325, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124, 5012, 119, 1, 1, 1, 1, 1], -100, [52, 8130, 2, 2169, 119, 1, 1, 1, 1, 1, 1790, 2, 65, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 26460, 2, 65, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1], -90, [7147, 2365, 1701, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1, 297, 123, 1, 1, 1, 1, 2, 502, 119, 1, 1, 1, 1, 1, 20288, 215, 215, 215, 215, 215, 5173, 119, 1, 1, 1, 1, 1], -80, [54, 1, 55, 7039, 1054, 119, 1, 1, 1, 1, 1, 1188, 1677, 2, 51, 14, 3, 102, 1, 1, 1, 1, 1, 13, 1, 1, 1, 1, 2, 235, 20, 119, 1, 1, 1, 1, 1, 70, 2, 485, 123, 1, 1, 1, 6052, 2, 643, 2, 4286, 68, 362, 2162, 2, 6705, 215, 215, 215, 215, 215, 5175, 123, 1, 1, 1, 6697, 2], -70, [7797, 124, 2241, 124, 2016, 123, 1, 1, 1, 1, 2, 24176, 124, 91, 124, 91, 124, 91, 124, 91, 124, 306, 124, 941, 123, 1, 1, 1, 1, 2], -60, [108, 7042, 4099, 18, 2, 32, 71, 1, 1, 1, 18, 282, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1, 36, 46, 73, 1, 1, 1, 1, 1, 45, 1, 1, 1, 1, 2, 5609, 2, 5874, 34, 9183, 215, 215, 215, 215, 215], -50, [7134, 14, 124, 1, 1, 1, 2863, 21, 1, 1, 96, 1, 1, 1, 1, 1, 542, 3, 124, 497, 119, 1, 1, 1, 1, 1, 97, 8, 22, 101, 1, 1, 1, 1, 2, 16, 1, 1, 1, 476, 1, 20437, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 74, 14, 124, 1, 1, 1, 2648, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 21, 1, 1, 96, 1, 1, 1, 1, 1, 306, 21, 1, 1, 96, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 84, 1], -46, [23328, 216], -45, [11910, 124, 1, 1, 1], -40, [2580, 430, 2580, 215, 1325, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 502, 21, 1, 97, 1, 1, 1, 1, 1, 1437, 32, 92, 659, 2, 38, 242, 123, 1, 1, 1, 1, 2, 277, 401, 1, 20, 123, 1, 1, 1, 1, 2, 280, 1, 201, 52, 119, 1, 1, 1, 1, 1, 4842, 1861, 2, 4798, 9198, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 74, 12, 2, 37, 73, 11, 1, 1, 1, 1, 2, 2631, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 390, 2, 38, 5409], -35, [9324, 123, 1, 1, 1, 1, 2, 2441, 123, 1, 1, 1], -30, [7180, 2, 2, 32, 88, 1, 1, 1, 1, 35, 119, 1, 1, 1, 1, 1, 285, 2, 1538, 38, 85, 1, 1, 1, 1, 2, 33, 1, 1, 1, 92, 32, 92, 712, 4, 115, 1, 1, 1, 1, 1, 3, 1, 1, 1, 892, 2, 5235, 32, 92, 305, 1496, 123, 1, 1, 1, 1, 2, 502, 119, 1, 1, 1, 1, 1, 6756, 119, 1, 1, 1, 1, 1, 6561, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 87, 2, 2, 32, 88, 1, 1, 1, 1, 4099, 2, 213, 2, 213, 2, 213, 2, 4804, 215, 215, 215, 215, 430, 1052, 119, 1, 1, 1, 1, 1], -25, [19214, 123, 1, 1, 1, 1, 2, 6751, 123, 1, 1, 1, 1, 2, 19651, 123, 1, 1, 1, 1, 2], -20, [8235, 119, 1, 1, 1, 1, 1, 683, 2, 19, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1, 1555, 5, 1, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 942, 42, 32, 49, 1, 1, 1, 1, 2, 37, 2026, 32, 92, 87, 1, 3, 32, 88, 1, 1, 1, 1, 77, 1, 648, 123, 1, 1, 1, 1, 2, 311, 32, 92, 947, 124, 1, 1, 1, 92, 32, 92, 88, 3, 32, 92, 445, 54, 1, 11, 2, 110, 11, 1, 1, 1, 1, 2, 717, 119, 1, 1, 1, 1, 1, 105, 123, 1, 1, 1, 1, 2, 4598, 10, 16128, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 292, 1, 2163, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 88, 3, 32, 92, 303, 3, 32, 92], -15, [9314, 123, 1, 1, 1, 4621, 1, 644, 1, 2, 32, 92, 88, 1, 1, 1, 32, 92, 1156, 123, 1, 1, 1, 1, 2, 94, 2, 32, 92, 519, 217, 32, 92, 288, 12, 34, 185, 7310, 14404, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 644, 1, 1, 1, 32, 92, 88, 1, 1, 1, 32, 92, 88, 1, 1, 1, 32, 92, 88, 1, 1, 1, 32, 92, 1379, 215, 215, 215, 215, 430], -10, [7363, 124, 1, 1, 1, 3098, 124, 1, 1, 1, 1136, 1, 2194, 220, 211, 17, 32, 92, 70, 374, 2, 55, 123, 1, 1, 1, 91, 1519, 124, 1, 1, 1, 2007, 123, 1, 1, 1, 89, 123, 1, 1, 1, 6754, 123, 1, 1, 1, 13421, 215, 215, 215, 215, 215, 431, 17, 32, 92, 2022, 124, 1, 1, 1, 2437, 123, 1, 1, 1], 10, [14847, 487, 123, 1, 1, 1, 2256, 3, 32, 92, 1576, 123, 1, 1, 1, 6324, 123, 1, 1, 1, 15297, 215, 215, 215], 20, [10547, 2, 4300, 2865, 23580, 215, 215, 215], 30, [15159, 2]]
};
var HelveticaOblique = {
name: 'Helvetica-Oblique',
bbox: [-170, -225, 1116, 931],
ascender: 718,
descender: -207,
xHeight: 523,
capHeight: 718,
glyphNames,
glyphWidths: [278, 278, 355, 556, 556, 889, 667, 191, 333, 333, 389, 584, 278, 333, 278, 278, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 278, 278, 584, 584, 584, 556, 1015, 667, 667, 722, 722, 667, 611, 778, 722, 278, 500, 667, 556, 833, 722, 778, 667, 778, 722, 667, 611, 722, 667, 944, 667, 667, 611, 278, 278, 278, 469, 556, 333, 556, 556, 500, 556, 556, 278, 556, 556, 222, 222, 500, 222, 833, 556, 556, 556, 556, 333, 500, 278, 556, 500, 722, 500, 500, 500, 334, 260, 334, 584, 556, 222, 556, 333, 1000, 556, 556, 333, 1000, 667, 333, 1000, 611, 222, 222, 333, 333, 350, 556, 1000, 333, 1000, 500, 333, 944, 500, 500, 333, 556, 556, 556, 556, 260, 556, 333, 737, 370, 556, 584, 737, 333, 400, 584, 333, 333, 333, 556, 537, 278, 333, 333, 365, 556, 834, 834, 834, 611, 667, 667, 667, 667, 667, 667, 1000, 722, 667, 667, 667, 667, 278, 278, 278, 278, 722, 722, 778, 778, 778, 778, 778, 584, 778, 722, 722, 722, 722, 667, 667, 611, 556, 556, 556, 556, 556, 556, 889, 500, 556, 556, 556, 556, 278, 278, 278, 278, 556, 556, 556, 556, 556, 556, 556, 584, 611, 556, 556, 556, 556, 500, 556],
kernPairs: [-180, [10332, 2], -160, [9569], -150, [8182, 2], -140, [9517, 54, 70, 1552, 1074, 1, 1, 51, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 26464, 1, 1, 51, 4, 10, 105, 1, 1, 2, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2], -125, [11622, 2], -120, [7147, 3206, 119, 1, 1, 1, 1, 1, 715, 2, 19, 32, 4, 10, 3, 3, 2, 2, 63, 1, 1, 1, 1, 1, 27, 1, 1, 2, 1, 4, 1, 1, 7, 1, 1, 2, 2, 1, 1, 1, 1, 1, 21339, 215, 215, 215, 215, 215], -110, [9512, 2, 2774, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1, 26481, 52, 67, 1, 1, 1, 1, 1, 52, 1, 1, 1], -100, [2689, 2, 428, 2, 4031, 124, 11871, 2, 6878, 2, 6708, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124, 11871, 2], -95, [44732, 2], -90, [57, 124, 7616, 124], -85, [12302, 123, 1, 1, 1, 1, 2, 26531, 123, 1, 1, 1, 1, 2, 5717], -80, [8203, 119, 1, 1, 1, 1, 1, 3296, 20, 36, 10, 73, 1, 1, 1, 1, 1, 35, 1, 1, 1, 7, 1, 1, 1, 1, 2, 19, 2, 6663, 2], -70, [7149, 603, 2, 40, 1721, 647, 124, 1389, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1, 11613, 9299, 215, 215, 215, 215, 215, 2798, 124, 91, 124, 91, 124, 91, 124, 91, 124, 306, 124, 1081, 5704, 1, 2, 32, 92], -60, [108, 2902, 7151, 1140, 66, 5, 13, 896, 1, 6435, 2, 17887, 215, 215, 215, 215, 430, 1045, 1], -57, [23328, 216], -55, [44785, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 27, 3, 64, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1], -50, [52, 2, 5536, 215, 1343, 2, 122, 1, 1, 1, 960, 119, 1, 1, 1, 1, 1, 933, 42, 32, 49, 1, 1, 1, 1, 2, 37, 701, 230, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 276, 3, 124, 927, 119, 1, 1, 1, 1, 1, 5660, 2, 5859, 14, 1, 34, 9181, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 88, 2, 122, 1, 1, 1, 2669, 215, 215, 215, 215, 430], -45, [8252], -40, [55, 7126, 1, 2, 32, 92, 465, 22, 97, 1, 1, 1, 1, 1, 1417, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 664, 2, 38, 228, 119, 1, 1, 1, 1, 1, 294, 124, 1, 1, 1, 297, 123, 1, 1, 1, 1, 2, 51, 2, 19, 119, 1, 1, 1, 1, 1, 84, 1, 12, 8, 123, 1, 1, 1, 1, 2, 52, 52, 119, 1, 1, 1, 1, 1, 2188, 2, 2793, 2, 6866, 8901, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 88, 1, 2, 32, 92, 2594, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 175, 2, 38, 390, 2, 38, 175, 2, 19, 119, 1, 1, 1, 1, 1, 70, 2, 19, 119, 1, 1, 1, 1, 1, 70, 2, 19, 119, 1, 1, 1, 1, 1, 70, 2, 19, 119, 1, 1, 1, 1, 1, 4585, 2, 213, 2, 213, 2, 213, 2, 213, 2], -35, [17212, 2], -30, [110, 7020, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 230, 2, 700, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 664, 2, 286, 124, 1, 1, 1, 92, 32, 92, 487, 642, 3, 1089, 10, 6, 107, 1, 1, 1, 7, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2027, 32, 92, 733, 2, 139, 2, 51, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 311, 32, 92, 1380, 1, 32, 92, 91, 32, 92, 519, 1057, 123, 1, 1, 1, 6127, 7473, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 38, 4, 8, 2, 36, 74, 11, 1, 1, 1, 1, 2, 33, 1, 1, 1, 230, 2, 2406, 215, 215, 215, 215, 430, 1754, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 518, 2, 213, 2, 213, 2, 213, 2, 1505, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92], -25, [18555, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2], -20, [7322, 2, 1739, 32, 20, 67, 1, 1, 1, 1, 1, 27, 1, 1, 1, 1, 1, 20, 1, 1, 1, 896, 119, 1, 1, 1, 1, 1, 535, 123, 1, 1, 1, 1, 2, 51, 2, 227, 1, 665, 42, 32, 49, 1, 1, 1, 1, 2, 37, 290, 124, 1609, 1, 204, 9, 1, 3, 32, 88, 1, 1, 1, 1, 77, 442, 2, 32, 92, 1146, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 523, 2344, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 3029, 2, 3706, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 10360, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 306, 119, 1, 1, 1, 1, 1, 991, 124, 534, 1, 214, 1, 214, 1, 214, 1, 214, 1, 214, 1, 418, 227, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 1163, 2559, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2], -15, [14417, 430, 2, 1795, 32, 92, 91, 32, 92, 88, 1, 785, 2, 911, 119, 1, 1, 1, 1, 1, 525, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 5609, 2, 700, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 15069, 215, 2, 213, 2, 213, 2, 213, 2, 1365, 32, 92, 88, 1, 214, 1, 214, 1, 214, 1, 214, 1], -10, [7363, 124, 1, 1, 1, 3098, 124, 1, 1, 1, 3541, 1091, 1293, 124, 1, 1, 1, 88, 124, 1, 1, 1, 713, 119, 1, 1, 1, 1, 1, 955, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 24387, 124, 1, 1, 1], 15, [17703, 2, 1, 9, 111, 1, 1, 1, 10, 1, 1, 1], 25, [17707, 1, 123], 30, [17656, 1, 53, 6, 3, 32, 92], 40, [17714], 50, [15159], 60, [15161]]
};
var Symbol$1 = {
name: 'Symbol',
bbox: [-180, -293, 1090, 1010],
ascender: 0,
descender: 0,
xHeight: 0,
capHeight: 0,
glyphNames: 'space exclam numbersign percent ampersand parenleft parenright plus comma period slash zero one two three four five six seven eight nine colon semicolon less equal greater question bracketleft bracketright underscore braceleft bar braceright Euro florin ellipsis bullet logicalnot degree plusminus mu multiply divide',
glyphWidths: [250, 333, 500, 833, 778, 333, 333, 549, 250, 250, 278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 278, 278, 549, 549, 549, 444, 333, 333, 500, 480, 200, 480, 750, 500, 1000, 460, 713, 400, 549, 576, 549, 549],
kernPairs: []
};
var TimesBold = {
name: 'Times-Bold',
bbox: [-168, -218, 1000, 935],
ascender: 683,
descender: -217,
xHeight: 461,
capHeight: 676,
glyphNames,
glyphWidths: [250, 333, 555, 500, 500, 1000, 833, 278, 333, 333, 500, 570, 250, 333, 250, 278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 333, 333, 570, 570, 570, 500, 930, 722, 667, 722, 722, 667, 611, 778, 778, 389, 500, 778, 667, 944, 722, 778, 611, 778, 722, 556, 667, 722, 722, 1000, 722, 722, 667, 333, 278, 333, 581, 500, 333, 500, 556, 444, 556, 444, 333, 500, 556, 278, 333, 556, 278, 833, 556, 500, 556, 556, 444, 389, 333, 556, 500, 722, 500, 500, 444, 394, 220, 394, 520, 500, 333, 500, 500, 1000, 500, 500, 333, 1000, 556, 333, 1000, 667, 333, 333, 500, 500, 350, 500, 1000, 333, 1000, 389, 333, 722, 444, 500, 333, 500, 500, 500, 500, 220, 500, 333, 747, 300, 500, 570, 747, 333, 400, 570, 300, 300, 333, 556, 540, 250, 333, 300, 330, 500, 750, 750, 750, 500, 722, 722, 722, 722, 722, 722, 1000, 722, 667, 667, 667, 667, 389, 389, 389, 389, 722, 722, 778, 778, 778, 778, 778, 570, 778, 722, 722, 722, 722, 722, 611, 556, 500, 500, 500, 500, 500, 500, 722, 444, 444, 444, 444, 444, 278, 278, 278, 278, 500, 556, 500, 500, 500, 500, 500, 570, 500, 556, 556, 556, 556, 500, 556],
kernPairs: [-145, [7149, 4475, 21110, 215, 215, 215, 215, 215], -135, [11643, 119, 1, 1, 1, 1, 1], -130, [7150, 25585, 215, 215, 215, 215, 215], -129, [11622], -120, [11858, 119, 1, 1, 1, 1, 1], -111, [12324, 10, 114, 1, 8, 1, 1, 1, 1, 2, 26521, 10, 114, 1, 8, 1, 1, 1, 1, 2], -110, [8184, 1385, 765, 1954, 119, 1, 1, 1, 1, 1, 26536, 119, 1, 1, 1, 1, 1], -100, [7152, 29, 95, 4403, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 5826, 15093, 29, 95, 91, 29, 95, 91, 29, 95, 91, 29, 95, 91, 29, 95, 91, 29, 95], -95, [7147, 25585, 215, 215, 215, 215, 215], -92, [8182, 1330, 2, 1, 2, 124, 691, 861, 52, 4, 10, 6, 100, 4, 4, 1, 8, 1, 1, 1, 1, 2, 1, 1, 1, 1, 244, 1, 38, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1, 15, 2, 428, 1, 1, 12, 1, 58, 124, 1, 1, 1, 5175, 21285, 1, 1, 12, 1, 58, 124, 1, 1, 1], -90, [7182, 1021, 119, 1, 1, 1, 1, 1, 2867, 19, 119, 1, 1, 1, 1, 1, 21430, 215, 215, 215, 215, 215], -85, [12320, 119, 1, 1, 1, 1, 1, 26536, 119, 1, 1, 1, 1, 1], -75, [11904, 123, 1, 1, 1, 1, 2], -74, [7184, 20, 12, 92, 3045, 119, 1, 1, 1, 1, 1, 715, 14, 1, 55, 5, 356, 11812, 9334, 20, 12, 92, 91, 20, 12, 92, 91, 20, 12, 92, 91, 20, 12, 92, 91, 20, 12, 92, 91, 20, 12, 92], -71, [12447, 3, 26657, 3], -70, [18504, 215, 430, 6880, 19780], -65, [11890, 4, 115, 1, 1, 1, 1, 1, 3, 1, 1, 1], -63, [23328, 216], -60, [11428, 119, 1, 1, 1, 1, 1, 362, 32, 92, 26050, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1], -55, [33, 24, 95, 1, 1, 1, 1, 1, 24, 2508, 430, 2, 4009, 4, 120, 2295, 32, 92, 1131, 1047, 1, 6650, 215, 430, 6880, 6688, 4, 120, 91, 4, 120, 91, 4, 120, 91, 4, 120, 91, 4, 120, 91, 4, 120, 11893], -52, [11364, 2, 1, 1, 4, 3], -50, [7148, 32, 92, 1, 1, 1, 29, 1, 1, 1, 2852, 1, 2, 124, 1121, 2, 501, 124, 1, 1, 1, 20696, 32, 92, 1, 1, 1, 29, 1, 1, 1, 56, 32, 92, 1, 1, 1, 29, 1, 1, 1, 56, 32, 92, 1, 1, 1, 29, 1, 1, 1, 56, 32, 92, 1, 1, 1, 29, 1, 1, 1, 56, 32, 92, 1, 1, 1, 29, 1, 1, 1, 56, 32, 92, 1, 1, 1, 29, 1, 1, 1, 2637, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 303, 1, 2, 124, 46, 2, 213, 2, 213, 2, 213, 2], -45, [54, 2637, 4451, 2, 121, 1, 1, 1, 1, 2, 2063, 32, 92, 2199, 123, 1, 1, 1, 1, 2, 20941, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2], -40, [7794, 1, 2, 124, 2217, 19, 4, 96, 1, 1, 1, 1, 1, 540, 3402, 2652, 19727, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 306, 19, 4, 96, 1, 1, 1, 1, 1, 5304], -37, [11683, 123, 1, 1, 1, 29, 490, 124, 5191, 5875, 34, 15436, 124], -35, [7773, 119, 1, 1, 1, 1, 1, 2908, 2, 124, 1371, 123, 1, 1, 1, 1, 2, 26531, 123, 1, 1, 1, 1, 2], -34, [11269, 32, 92], -30, [52, 3, 7288, 119, 1, 1, 1, 1, 1, 1596, 119, 1, 1, 1, 1, 1, 105, 123, 1, 1, 1, 1, 2, 1376, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 719], -25, [7175, 1060, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 936, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 4608, 1062, 6, 123, 1, 1, 1, 1, 2, 3956, 123, 1, 1, 1, 1, 2, 6751, 123, 1, 1, 1, 1, 2, 6537, 215, 215, 215, 215, 215, 5811, 215, 215, 215, 215, 215, 5153, 123, 1, 1, 1, 1, 2], -20, [7754, 1290, 527, 352, 119, 1, 1, 1, 1, 1, 342, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 21, 3726, 124, 1, 1, 1, 9101, 14, 4, 12847, 119, 1, 1, 1, 1, 1], -18, [11227, 26, 97, 1, 1, 1, 1, 2, 21, 521, 124, 5675, 2, 10, 2, 110, 1, 1, 1, 1, 7, 1, 1, 1, 1, 2], -15, [9095, 4, 10, 6, 99, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 1, 1, 1, 1, 88, 124, 1, 1, 1, 4819, 431, 214, 141, 2, 215, 290, 32, 92, 511, 10, 32, 81, 1, 1, 1, 1, 2, 5, 1370, 123, 23535, 215, 215, 215], -10, [7363, 124, 1, 1, 1, 2895, 119, 1, 1, 1, 1, 1, 79, 124, 1, 1, 1, 1157, 123, 1, 1, 1, 1, 2, 2255, 1525, 413, 123, 1, 1, 1, 751, 1, 629, 9, 6, 839, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 86, 123, 1, 1, 1, 1, 2, 291, 123, 1, 1, 1, 3923, 119, 1, 1, 1, 1, 1, 306, 119, 1, 1, 1, 1, 1, 2277, 123, 1, 1, 1, 16016, 215, 215, 215, 645, 1, 214, 1, 214, 1, 214, 1, 214, 1, 429, 1, 1057, 123, 1, 1, 1], 50, [15161], 55, [15159]]
};
var TimesBoldItalic = {
name: 'Times-BoldItalic',
bbox: [-200, -218, 996, 921],
ascender: 683,
descender: -217,
xHeight: 462,
capHeight: 669,
glyphNames,
glyphWidths: [250, 389, 555, 500, 500, 833, 778, 278, 333, 333, 500, 570, 250, 333, 250, 278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 333, 333, 570, 570, 570, 500, 832, 667, 667, 667, 722, 667, 667, 722, 778, 389, 500, 667, 611, 889, 722, 722, 611, 722, 667, 556, 611, 722, 667, 889, 667, 611, 611, 333, 278, 333, 570, 500, 333, 500, 500, 444, 500, 444, 333, 500, 556, 278, 278, 500, 278, 778, 556, 500, 500, 500, 389, 389, 278, 556, 444, 667, 500, 444, 389, 348, 220, 348, 570, 500, 333, 500, 500, 1000, 500, 500, 333, 1000, 556, 333, 944, 611, 333, 333, 500, 500, 350, 500, 1000, 333, 1000, 389, 333, 722, 389, 444, 389, 500, 500, 500, 500, 220, 500, 333, 747, 266, 500, 606, 747, 333, 400, 570, 300, 300, 333, 576, 500, 250, 333, 300, 300, 500, 750, 750, 750, 500, 667, 667, 667, 667, 667, 667, 944, 667, 667, 667, 667, 667, 389, 389, 389, 389, 722, 722, 722, 722, 722, 722, 722, 570, 722, 722, 722, 722, 722, 611, 611, 500, 500, 500, 500, 500, 500, 500, 722, 444, 444, 444, 444, 444, 278, 278, 278, 278, 500, 556, 500, 500, 500, 500, 500, 570, 500, 556, 556, 556, 556, 444, 500],
kernPairs: [-129, [8182, 2, 2148, 2, 1288, 2], -111, [11675, 4, 10, 105, 1, 1, 1, 1, 1, 4, 1, 8, 1, 1, 1, 1, 2, 506, 10, 114, 9, 1, 1, 1, 1, 2, 26521, 10, 114, 9, 1, 1, 1, 1, 2], -100, [7150, 1053, 36, 83, 1, 1, 1, 1, 1, 35, 1, 1, 1, 24370, 215, 215, 215, 215, 215], -95, [2689, 2, 428, 2, 4028, 1086, 119, 1, 1, 1, 1, 1, 2900, 123, 1, 1, 1, 1, 2, 21346, 215, 215, 215, 215, 215], -92, [11192, 1, 1, 51, 4, 115, 1, 1, 1, 1, 1, 4, 1, 893, 1, 13, 1, 38, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1, 26460, 1, 13, 1, 38, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1], -90, [11894, 124, 1], -85, [10353, 119, 1, 1, 1, 1, 1, 1166, 119, 1, 1, 1, 1, 1, 123, 119, 1, 1, 1, 1, 1], -80, [11904, 123, 1, 1, 1, 1, 2], -74, [7181, 1, 2, 20, 12, 92, 3898, 1, 429, 1, 200, 2, 19, 119, 1, 1, 1, 1, 1, 287, 19, 119, 1, 1, 1, 1, 1, 10916, 107, 83, 26, 8, 9214, 1, 2, 20, 12, 92, 88, 1, 2, 20, 12, 92, 88, 1, 2, 20, 12, 92, 88, 1, 2, 20, 12, 92, 88, 1, 2, 20, 12, 92, 88, 1, 2, 20, 12, 92, 4961, 19, 119, 1, 1, 1, 1, 1], -71, [11802, 3, 642, 2, 1, 26657, 2, 1], -70, [54, 1, 2, 124, 6971, 124, 973, 123, 1, 1, 1, 1, 2, 3245, 21114, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124], -65, [7130, 124, 10388, 2, 15071, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124], -60, [7134, 25585, 215, 215, 215, 215, 215], -55, [7144, 3, 2422, 830, 123, 1, 1, 1, 1, 2, 685, 119, 1, 1, 1, 1, 1, 346, 12, 112, 12, 1, 1, 1, 29, 1, 58, 4, 32, 88, 1, 1, 1, 1, 290, 124, 20277, 3, 212, 3, 212, 3, 212, 3, 212, 3, 212, 3, 5181, 124], -52, [11372, 3], -50, [7142, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 519, 3, 124, 331, 1907, 1, 2, 124, 103, 123, 1, 1, 1, 1323, 179, 3, 20707, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2669, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 303, 1, 2, 124], -45, [11428, 119, 1, 1, 1, 1, 1, 26536, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1], -40, [7795, 448, 123, 1, 1, 1, 726, 4, 10, 6, 99, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2, 1, 1, 1, 1, 896, 19, 4, 96, 1, 1, 1, 1, 1, 123, 119, 1, 1, 1, 1, 1, 288, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 3274, 2652, 19727, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 91, 19, 4, 96, 1, 1, 1, 1, 1, 306, 19, 4, 96, 1, 1, 1, 1, 1, 5304], -37, [33, 119, 1, 1, 1, 1, 1, 9357, 1, 2, 32, 32, 60, 32, 1580, 9, 3, 2, 2, 32, 76, 12, 1, 1, 1, 1, 505, 124, 6480, 2, 213, 2, 428, 2, 4370, 2508, 2, 19778, 2], -30, [7180, 124, 1, 1, 1, 1985, 123, 1, 1, 1, 1, 2, 502, 119, 1, 1, 1, 1, 1, 755, 855, 123, 1, 1, 1, 1, 2, 4408, 123, 1, 1, 1, 16445, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 2401, 119, 1, 1, 1, 1, 1], -25, [7343, 119, 1, 1, 1, 1, 1, 306, 119, 1, 1, 1, 1, 1, 1166, 119, 1, 1, 1, 1, 1, 127, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 2849, 123, 1, 1, 1, 1, 2, 4641, 21890, 123, 1, 1, 1, 1, 2, 4426, 215, 215, 215, 215, 430], -20, [9330, 4, 32, 88, 1, 1, 1, 1, 4817, 124, 1, 1, 1], -18, [9512, 1292, 1, 2, 124, 296, 123, 1, 1, 1, 1, 2, 3764], -15, [11872, 123, 1, 1, 1, 1, 2, 5070, 1488, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 86, 123, 1, 1, 1, 1, 2, 4590, 14, 4, 19995, 215, 215, 215, 215, 430], -10, [7363, 124, 1, 1, 1, 1552, 2, 1544, 124, 1, 1, 1, 934, 2607, 221, 3, 421, 161, 2, 55, 10, 114, 9, 1, 1, 1, 3, 946, 123, 1, 1, 1, 1, 2, 740, 1, 32, 92, 1572, 4, 115, 1, 1, 1, 1, 1, 3, 1, 1, 1, 89, 123, 1, 1, 1, 22022, 3, 206, 215, 215, 215, 1527, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92, 90, 1, 32, 92, 305, 1, 32, 92], 55, [15159]]
};
var TimesItalic = {
name: 'Times-Italic',
bbox: [-169, -217, 1010, 883],
ascender: 683,
descender: -217,
xHeight: 441,
capHeight: 653,
glyphNames,
glyphWidths: [250, 333, 420, 500, 500, 833, 778, 214, 333, 333, 500, 675, 250, 333, 250, 278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 333, 333, 675, 675, 675, 500, 920, 611, 611, 667, 722, 611, 611, 722, 722, 333, 444, 667, 556, 833, 667, 722, 611, 722, 611, 500, 556, 722, 611, 833, 611, 556, 556, 389, 278, 389, 422, 500, 333, 500, 500, 444, 500, 444, 278, 500, 500, 278, 278, 444, 278, 722, 500, 500, 500, 500, 389, 389, 278, 500, 444, 667, 444, 444, 389, 400, 275, 400, 541, 500, 333, 500, 556, 889, 500, 500, 333, 1000, 500, 333, 944, 556, 333, 333, 556, 556, 350, 500, 889, 333, 980, 389, 333, 667, 389, 444, 389, 500, 500, 500, 500, 275, 500, 333, 760, 276, 500, 675, 760, 333, 400, 675, 300, 300, 333, 500, 523, 250, 333, 300, 310, 500, 750, 750, 750, 500, 611, 611, 611, 611, 611, 611, 889, 667, 611, 611, 611, 611, 333, 333, 333, 333, 722, 667, 722, 722, 722, 722, 722, 675, 722, 722, 722, 722, 722, 556, 611, 500, 500, 500, 500, 500, 500, 500, 667, 444, 444, 444, 444, 444, 278, 278, 278, 278, 500, 500, 500, 500, 500, 500, 500, 675, 500, 500, 500, 500, 500, 444, 500],
kernPairs: [-140, [2689, 2, 428, 2], -135, [8182, 2, 2148, 2], -129, [11622, 2], -115, [8203, 119, 1, 1, 1, 1, 1], -111, [11675, 4, 10, 105, 1, 1, 1, 1, 1, 4, 1, 8, 1, 1, 1, 1, 2, 5824, 2, 5684, 107, 109], -105, [7149, 1100, 123, 1, 1, 1, 1, 2, 24356, 215, 215, 215, 215, 215], -95, [7150, 25585, 215, 215, 215, 215, 215], -92, [11245, 4, 10, 105, 1, 1, 1, 1, 1, 4, 9, 1, 1, 1, 1, 2, 449, 2, 51, 4, 10, 105, 1, 1, 1, 1, 1, 4, 1, 8, 1, 1, 1, 1, 2, 234, 2, 51, 4, 10, 6, 99, 1, 1, 1, 1, 1, 4, 1, 8, 1, 1, 1, 1, 2, 1, 1, 1, 1, 26460, 2, 51, 4, 10, 6, 99, 1, 1, 1, 1, 1, 4, 1, 8, 1, 1, 1, 1, 2, 1, 1, 1, 1], -90, [10353, 119, 1, 1, 1, 1, 1], -80, [10385, 4, 10, 105, 1, 1, 1, 1, 1, 3, 1, 1, 1, 7, 1, 1, 1, 1, 2], -75, [57, 124, 8054, 4, 115, 1, 1, 1, 1, 1, 3, 1, 1, 1], -74, [11192, 1, 1, 73, 2, 124, 244, 46, 12, 112, 12, 1, 1, 1, 446, 60, 124, 6050, 2, 213, 2, 20209, 60, 124], -71, [11802, 3], -70, [11914, 32, 92], -65, [11207, 429, 215, 1, 429, 1, 26659, 1], -60, [11643, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1], -55, [7152, 29, 1, 2, 32, 60, 32, 944, 1262, 1, 623, 119, 1, 1, 1, 1, 1, 944, 47, 9, 3, 112, 12, 1, 1, 1, 231, 275, 12, 112, 12, 1, 1, 1, 7110, 2, 6878, 2, 6708, 29, 1, 2, 32, 60, 32, 59, 29, 1, 2, 32, 60, 32, 59, 29, 1, 2, 32, 60, 32, 59, 29, 1, 2, 32, 60, 32, 59, 29, 1, 2, 32, 60, 32, 59, 29, 1, 2, 32, 60, 32, 2615, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 306, 119, 1, 1, 1, 1, 1, 7810, 2], -52, [11372, 2, 1, 642, 3, 427, 3, 26657, 3], -50, [7148, 124, 1, 1, 1, 2017, 123, 1, 1, 1, 1, 2, 738, 1, 2, 124, 927, 119, 1, 1, 1, 1, 1, 951, 119, 1, 1, 1, 1, 1, 20321, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 2669, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 88, 1, 2, 124, 303, 1, 2, 124, 927, 119, 1, 1, 1, 1, 1], -45, [8243, 123, 1, 1, 1, 9340, 123, 1, 1, 1, 1, 2], -40, [55, 7087, 2, 121, 1, 1, 1, 1, 2, 523, 1, 2, 124, 1142, 119, 1, 1, 1, 1, 1, 137, 6, 4, 32, 81, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 699, 4, 636, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 498, 119, 1, 1, 1, 1, 1, 2652, 702, 1950, 6662, 34, 9175, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 86, 2, 121, 1, 1, 1, 1, 2, 2671, 4, 211, 4, 211, 4, 211, 4, 211, 4, 426, 4, 192, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 2494, 215, 215, 215, 1305], -37, [7147, 57, 2365, 2269, 5859, 1, 1, 2, 10, 110, 1, 1, 1, 1, 14907, 57, 158, 57, 158, 57, 158, 57, 158, 57, 158, 57], -35, [54, 7080, 639, 119, 1, 1, 1, 1, 1, 1198, 20, 99, 1, 1, 1, 1, 1, 20, 1, 1, 1, 72, 123, 1, 1, 1, 23279, 215, 215, 215, 215, 215], -34, [11301, 505, 2, 1, 642, 2, 1, 26657, 2, 1], -30, [7130, 124, 2295, 32, 92, 1984, 123, 1, 1, 1, 1, 2, 3138, 32, 92, 8471, 9196, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124, 7455, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92], -27, [9923, 119, 1, 1, 1, 1, 1, 26321, 119, 1, 1, 1, 1, 1], -25, [7343, 119, 1, 1, 1, 1, 1, 1575, 2, 55, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 2169, 2, 463, 123, 1, 1, 1, 1, 2, 11502, 14, 14550, 2, 213, 2, 213, 2, 213, 2], -20, [7180, 124, 1, 1, 1, 2205, 5, 124, 4634, 124, 1, 1, 1, 78, 443, 200, 2520, 15122, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 88, 124, 1, 1, 1, 7173, 228, 215, 215, 215], -18, [33, 19, 100, 1, 1, 1, 1, 1, 10647, 1, 2, 124, 296, 123, 1, 1, 1, 1, 2, 3764], -15, [12302, 123, 1, 1, 1, 1, 2, 2046, 372, 72, 1, 142, 215, 2416, 119, 1, 1, 1, 1, 1, 21143, 123, 1, 1, 1, 1, 2, 2046, 157, 72, 1, 142, 72, 1, 142, 72, 1, 142, 72, 1], -10, [7363, 124, 1, 1, 1, 3098, 124, 1, 1, 1, 3331, 801, 215, 215, 57, 2, 121, 1, 1, 1, 734, 10, 10, 32, 71, 1, 1, 1, 7, 1, 1, 1, 1, 2, 5, 718, 15, 642, 34, 5774, 16110, 215, 215, 215, 215, 215, 586, 215, 215, 215, 1564, 15, 200, 15, 200, 15, 200, 15, 200, 15, 415, 15], 92, [15159]]
};
var TimesRoman = {
name: 'Times-Roman',
bbox: [-168, -218, 1000, 898],
ascender: 683,
descender: -217,
xHeight: 450,
capHeight: 662,
glyphNames,
glyphWidths: [250, 333, 408, 500, 500, 833, 778, 180, 333, 333, 500, 564, 250, 333, 250, 278, 500, 500, 500, 500, 500, 500, 500, 500, 500, 500, 278, 278, 564, 564, 564, 444, 921, 722, 667, 667, 722, 611, 556, 722, 722, 333, 389, 722, 611, 889, 722, 722, 556, 722, 667, 556, 611, 722, 722, 944, 722, 722, 611, 333, 278, 333, 469, 500, 333, 444, 500, 444, 500, 444, 333, 500, 500, 278, 278, 500, 278, 778, 500, 500, 500, 500, 333, 389, 278, 500, 500, 722, 500, 500, 444, 480, 200, 480, 541, 500, 333, 500, 444, 1000, 500, 500, 333, 1000, 556, 333, 889, 611, 333, 333, 444, 444, 350, 500, 1000, 333, 980, 389, 333, 722, 444, 500, 333, 500, 500, 500, 500, 200, 500, 333, 760, 276, 500, 564, 760, 333, 400, 564, 300, 300, 333, 500, 453, 250, 333, 300, 310, 500, 750, 750, 750, 444, 722, 722, 722, 722, 722, 722, 889, 667, 611, 611, 611, 611, 333, 333, 333, 333, 722, 722, 722, 722, 722, 722, 722, 564, 722, 722, 722, 722, 722, 722, 556, 500, 444, 444, 444, 444, 444, 444, 667, 444, 444, 444, 444, 444, 278, 278, 278, 278, 500, 500, 500, 500, 500, 500, 500, 564, 500, 500, 500, 500, 500, 500, 500],
kernPairs: [-135, [7149, 4494, 119, 1, 1, 1, 1, 1, 20967, 215, 215, 215, 215, 215], -129, [11622, 2, 65, 124, 1, 4, 449, 2, 26658, 2], -120, [11858, 119, 1, 1, 1, 1, 1, 306, 119, 1, 1, 1, 1, 1, 26536, 119, 1, 1, 1, 1, 1], -111, [7147, 57, 3128, 2, 1341, 4, 116, 4, 4, 465, 72, 125, 1, 20266, 57, 158, 57, 158, 57, 158, 57, 158, 57, 158, 57, 5064, 72, 125, 1], -110, [12334, 124, 1, 4, 26531, 124, 1, 4], -105, [7152, 124, 25461, 124, 91, 124, 91, 124, 91, 124, 91, 124, 91, 124], -100, [9514, 3, 124, 1982, 697, 4, 116, 1, 3, 4, 1, 26531, 4, 116, 1, 3, 4, 1], -93, [11213, 119, 1, 1, 1, 1, 1], -92, [7182, 2, 32, 92, 2204, 57, 784, 119, 1, 1, 1, 1, 1, 716, 644, 2, 442, 1, 20485, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 89, 2, 32, 92, 4973, 1], -90, [57, 124, 6969, 25585, 215, 215, 215, 215, 215], -89, [11812, 3, 1], -80, [8182, 2, 2620, 441, 14, 8, 2, 32, 64, 1, 3, 13, 1, 1, 1, 1, 2, 5, 497, 4, 10, 105, 1, 1, 1, 1, 1, 4, 1, 8, 1, 1, 1, 1, 2, 11220, 119, 1, 1, 1, 1, 1, 306, 119, 1, 1, 1, 1, 1], -75, [11695, 124, 1, 1, 1], -74, [7181, 1022, 119, 1, 1, 1, 1, 1, 1188, 1677, 2, 442, 1, 11691, 107, 109, 9222, 215, 215, 215, 215, 215], -73, [11914, 32, 92], -71, [11794, 2, 1, 1, 4, 2, 1, 659, 3, 26657, 3], -70, [2689, 2, 428, 2, 8128, 123, 1, 1, 1083, 3, 1, 26656, 3, 1], -65, [10807, 124, 907, 6664, 2, 213, 2, 428, 2, 6878, 2, 19778, 2], -60, [9063, 119, 1, 1, 1, 1, 1, 1615, 881, 124, 632, 3, 1, 4, 3, 26649, 3, 1, 4, 3], -55, [33, 119, 1, 1, 1, 1, 1, 6985, 2, 4, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 522, 124, 1628, 32, 92, 1132, 402, 1121, 124, 5192, 5874, 34, 9175, 2, 4, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 2, 4, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 2, 4, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 2, 4, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 2, 4, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 82, 2, 4, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 5053, 124], -50, [54, 10105, 3, 124, 920, 704, 124, 1, 1, 1, 11466, 14, 4, 13083, 3, 124, 88, 3, 124, 88, 3, 124, 88, 3, 124, 88, 3, 124, 303, 3, 124], -45, [11265, 124, 1, 1, 1], -40, [7130, 4, 120, 519, 21, 98, 1, 1, 1, 1, 1, 2260, 4, 636, 6, 117, 1, 1, 1, 1, 2, 1, 1, 1, 1, 434, 3, 1, 60, 119, 1, 1, 1, 1, 1, 105, 123, 1, 1, 1, 1, 2, 112, 119, 3, 2, 2182, 2652, 786, 15073, 4, 120, 91, 4, 120, 91, 4, 120, 91, 4, 120, 91, 4, 120, 91, 4, 120, 2688, 4, 211, 4, 211, 4, 211, 4, 211, 4, 426, 4, 192, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 91, 119, 1, 1, 1, 1, 1, 4444], -37, [11851, 1], -35, [7343, 119, 1, 1, 1, 1, 1, 1857, 123, 1, 1, 1, 1, 2, 470, 119, 1, 1, 1, 1, 1, 91, 22, 97, 1, 1, 1, 1, 1, 991, 9, 115, 24991, 119, 1, 1, 1, 1, 1, 91, 22, 97, 1, 1, 1, 1, 1, 91, 22, 97, 1, 1, 1, 1, 1, 91, 22, 97, 1, 1, 1, 1, 1, 91, 22, 97, 1, 1, 1, 1, 1, 91, 22, 97, 1, 1, 1, 1, 1, 306, 22, 97, 1, 1, 1, 1, 1], -30, [55, 7740, 1497, 123, 1, 1, 1, 1, 2, 1954, 927, 123, 1, 1, 1, 1, 2, 26531, 123, 1, 1, 1, 1, 2], -25, [9314, 20, 32, 71, 1, 1, 1, 18, 5463, 1, 198, 661, 1291, 1483, 119, 1, 1, 1, 1, 1, 22687, 1, 214, 1, 214, 1, 214, 1, 214, 215, 215, 215, 646, 215, 215, 215, 215, 430], -20, [11806, 2, 1, 2252, 214, 124, 1, 1, 1, 721, 124, 2396, 926, 123, 1, 1, 1, 1, 2, 20948, 215, 215, 215, 215, 215], -18, [52, 11175, 123, 1, 1, 1, 1, 2, 6345, 5818], -15, [8235, 14, 105, 1, 1, 1, 1, 1, 13, 1, 1, 1, 1, 2, 952, 124, 1, 1, 1, 928, 119, 1, 1, 1, 1, 1, 1140, 2413, 214, 218, 32, 92, 288, 17, 1, 32, 92, 1166, 32, 92, 521, 32, 92, 88, 1488, 123, 1, 1, 1, 304, 123, 1, 1, 1, 20532, 215, 215, 215, 215, 215, 432, 32, 92, 73, 17, 1, 32, 92, 73, 17, 1, 32, 92, 73, 17, 1, 32, 92, 73, 17, 1, 32, 92, 1166, 32, 92, 88, 215, 215, 215, 215, 430], -10, [7363, 124, 1, 1, 1, 3098, 124, 1, 1, 1, 1157, 123, 1, 1, 1, 1, 2, 3114, 119, 1, 1, 1, 1, 1, 955, 10, 113, 1, 1, 1, 7, 1, 1, 1, 1, 2, 94, 647, 32, 92, 91, 32, 92, 1357, 14, 105, 1, 1, 1, 1, 1, 13, 1, 1, 1, 1, 2, 4598, 20008, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 91, 32, 92, 306, 32, 92], -5, [15330, 119, 1, 1, 1, 1, 1, 115, 32, 92], 55, [15159]]
};
var ZapfDingbats = {
name: 'ZapfDingbats',
bbox: [-1, -143, 981, 820],
ascender: 0,
descender: 0,
xHeight: 0,
capHeight: 0,
glyphNames: 'space',
glyphWidths: [278],
kernPairs: []
};
registerStdFonts(Courier, CourierBold, CourierBoldOblique, CourierOblique, Helvetica, HelveticaBold, HelveticaBoldOblique, HelveticaOblique, Symbol$1, TimesBold, TimesBoldItalic, TimesItalic, TimesRoman, ZapfDingbats);
exports.PDFDocument = PDFDocument;
exports.default = PDFDocument;
module.exports = exports.default;
module.exports.PDFDocument = exports.PDFDocument;
}).call(this)}).call(this,"/js/pdfkit.browser.js")
},{"@noble/ciphers/aes":3,"@noble/hashes/utils":6,"fflate":25,"fontkit":27,"linebreak":29,"png-js":31}],2:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.polyval = exports.ghash = void 0;
exports._toGHASHKey = _toGHASHKey;
/**
* GHash from AES-GCM and its little-endian "mirror image" Polyval from AES-SIV.
*
* Implemented in terms of GHash with conversion function for keys
* GCM GHASH from
* [NIST SP800-38d](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf),
* SIV from
* [RFC 8452](https://datatracker.ietf.org/doc/html/rfc8452).
*
* GHASH modulo: x^128 + x^7 + x^2 + x + 1
* POLYVAL modulo: x^128 + x^127 + x^126 + x^121 + 1
*
* @module
*/
// prettier-ignore
const utils_ts_1 = require("./utils.js");
const BLOCK_SIZE = 16;
// TODO: rewrite
// temporary padding buffer
const ZEROS16 = /* @__PURE__ */ new Uint8Array(16);
const ZEROS32 = (0, utils_ts_1.u32)(ZEROS16);
const POLY = 0xe1; // v = 2*v % POLY
// v = 2*v % POLY
// NOTE: because x + x = 0 (add/sub is same), mul2(x) != x+x
// We can multiply any number using montgomery ladder and this function (works as double, add is simple xor)
const mul2 = (s0, s1, s2, s3) => {
const hiBit = s3 & 1;
return {
s3: (s2 << 31) | (s3 >>> 1),
s2: (s1 << 31) | (s2 >>> 1),
s1: (s0 << 31) | (s1 >>> 1),
s0: (s0 >>> 1) ^ ((POLY << 24) & -(hiBit & 1)), // reduce % poly
};
};
const swapLE = (n) => (((n >>> 0) & 0xff) << 24) |
(((n >>> 8) & 0xff) << 16) |
(((n >>> 16) & 0xff) << 8) |
((n >>> 24) & 0xff) |
0;
/**
* `mulX_POLYVAL(ByteReverse(H))` from spec
* @param k mutated in place
*/
function _toGHASHKey(k) {
k.reverse();
const hiBit = k[15] & 1;
// k >>= 1
let carry = 0;
for (let i = 0; i < k.length; i++) {
const t = k[i];
k[i] = (t >>> 1) | carry;
carry = (t & 1) << 7;
}
k[0] ^= -hiBit & 0xe1; // if (hiBit) n ^= 0xe1000000000000000000000000000000;
return k;
}
const estimateWindow = (bytes) => {
if (bytes > 64 * 1024)
return 8;
if (bytes > 1024)
return 4;
return 2;
};
class GHASH {
// We select bits per window adaptively based on expectedLength
constructor(key, expectedLength) {
this.blockLen = BLOCK_SIZE;
this.outputLen = BLOCK_SIZE;
this.s0 = 0;
this.s1 = 0;
this.s2 = 0;
this.s3 = 0;
this.finished = false;
key = (0, utils_ts_1.toBytes)(key);
(0, utils_ts_1.abytes)(key, 16);
const kView = (0, utils_ts_1.createView)(key);
let k0 = kView.getUint32(0, false);
let k1 = kView.getUint32(4, false);
let k2 = kView.getUint32(8, false);
let k3 = kView.getUint32(12, false);
// generate table of doubled keys (half of montgomery ladder)
const doubles = [];
for (let i = 0; i < 128; i++) {
doubles.push({ s0: swapLE(k0), s1: swapLE(k1), s2: swapLE(k2), s3: swapLE(k3) });
({ s0: k0, s1: k1, s2: k2, s3: k3 } = mul2(k0, k1, k2, k3));
}
const W = estimateWindow(expectedLength || 1024);
if (![1, 2, 4, 8].includes(W))
throw new Error('ghash: invalid window size, expected 2, 4 or 8');
this.W = W;
const bits = 128; // always 128 bits;
const windows = bits / W;
const windowSize = (this.windowSize = 2 ** W);
const items = [];
// Create precompute table for window of W bits
for (let w = 0; w < windows; w++) {
// truth table: 00, 01, 10, 11
for (let byte = 0; byte < windowSize; byte++) {
// prettier-ignore
let s0 = 0, s1 = 0, s2 = 0, s3 = 0;
for (let j = 0; j < W; j++) {
const bit = (byte >>> (W - j - 1)) & 1;
if (!bit)
continue;
const { s0: d0, s1: d1, s2: d2, s3: d3 } = doubles[W * w + j];
(s0 ^= d0), (s1 ^= d1), (s2 ^= d2), (s3 ^= d3);
}
items.push({ s0, s1, s2, s3 });
}
}
this.t = items;
}
_updateBlock(s0, s1, s2, s3) {
(s0 ^= this.s0), (s1 ^= this.s1), (s2 ^= this.s2), (s3 ^= this.s3);
const { W, t, windowSize } = this;
// prettier-ignore
let o0 = 0, o1 = 0, o2 = 0, o3 = 0;
const mask = (1 << W) - 1; // 2**W will kill performance.
let w = 0;
for (const num of [s0, s1, s2, s3]) {
for (let bytePos = 0; bytePos < 4; bytePos++) {
const byte = (num >>> (8 * bytePos)) & 0xff;
for (let bitPos = 8 / W - 1; bitPos >= 0; bitPos--) {
const bit = (byte >>> (W * bitPos)) & mask;
const { s0: e0, s1: e1, s2: e2, s3: e3 } = t[w * windowSize + bit];
(o0 ^= e0), (o1 ^= e1), (o2 ^= e2), (o3 ^= e3);
w += 1;
}
}
}
this.s0 = o0;
this.s1 = o1;
this.s2 = o2;
this.s3 = o3;
}
update(data) {
(0, utils_ts_1.aexists)(this);
data = (0, utils_ts_1.toBytes)(data);
(0, utils_ts_1.abytes)(data);
const b32 = (0, utils_ts_1.u32)(data);
const blocks = Math.floor(data.length / BLOCK_SIZE);
const left = data.length % BLOCK_SIZE;
for (let i = 0; i < blocks; i++) {
this._updateBlock(b32[i * 4 + 0], b32[i * 4 + 1], b32[i * 4 + 2], b32[i * 4 + 3]);
}
if (left) {
ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
this._updateBlock(ZEROS32[0], ZEROS32[1], ZEROS32[2], ZEROS32[3]);
(0, utils_ts_1.clean)(ZEROS32); // clean tmp buffer
}
return this;
}
destroy() {
const { t } = this;
// clean precompute table
for (const elm of t) {
(elm.s0 = 0), (elm.s1 = 0), (elm.s2 = 0), (elm.s3 = 0);
}
}
digestInto(out) {
(0, utils_ts_1.aexists)(this);
(0, utils_ts_1.aoutput)(out, this);
this.finished = true;
const { s0, s1, s2, s3 } = this;
const o32 = (0, utils_ts_1.u32)(out);
o32[0] = s0;
o32[1] = s1;
o32[2] = s2;
o32[3] = s3;
return out;
}
digest() {
const res = new Uint8Array(BLOCK_SIZE);
this.digestInto(res);
this.destroy();
return res;
}
}
class Polyval extends GHASH {
constructor(key, expectedLength) {
key = (0, utils_ts_1.toBytes)(key);
(0, utils_ts_1.abytes)(key);
const ghKey = _toGHASHKey((0, utils_ts_1.copyBytes)(key));
super(ghKey, expectedLength);
(0, utils_ts_1.clean)(ghKey);
}
update(data) {
data = (0, utils_ts_1.toBytes)(data);
(0, utils_ts_1.aexists)(this);
const b32 = (0, utils_ts_1.u32)(data);
const left = data.length % BLOCK_SIZE;
const blocks = Math.floor(data.length / BLOCK_SIZE);
for (let i = 0; i < blocks; i++) {
this._updateBlock(swapLE(b32[i * 4 + 3]), swapLE(b32[i * 4 + 2]), swapLE(b32[i * 4 + 1]), swapLE(b32[i * 4 + 0]));
}
if (left) {
ZEROS16.set(data.subarray(blocks * BLOCK_SIZE));
this._updateBlock(swapLE(ZEROS32[3]), swapLE(ZEROS32[2]), swapLE(ZEROS32[1]), swapLE(ZEROS32[0]));
(0, utils_ts_1.clean)(ZEROS32);
}
return this;
}
digestInto(out) {
(0, utils_ts_1.aexists)(this);
(0, utils_ts_1.aoutput)(out, this);
this.finished = true;
// tmp ugly hack
const { s0, s1, s2, s3 } = this;
const o32 = (0, utils_ts_1.u32)(out);
o32[0] = s0;
o32[1] = s1;
o32[2] = s2;
o32[3] = s3;
return out.reverse();
}
}
function wrapConstructorWithKey(hashCons) {
const hashC = (msg, key) => hashCons(key, msg.length).update((0, utils_ts_1.toBytes)(msg)).digest();
const tmp = hashCons(new Uint8Array(16), 0);
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = (key, expectedLength) => hashCons(key, expectedLength);
return hashC;
}
/** GHash MAC for AES-GCM. */
exports.ghash = wrapConstructorWithKey((key, expectedLength) => new GHASH(key, expectedLength));
/** Polyval MAC for AES-SIV. */
exports.polyval = wrapConstructorWithKey((key, expectedLength) => new Polyval(key, expectedLength));
},{"./utils.js":4}],3:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.unsafe = exports.aeskwp = exports.aeskw = exports.siv = exports.gcmsiv = exports.gcm = exports.cfb = exports.cbc = exports.ecb = exports.ctr = void 0;
/**
* [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)
* a.k.a. Advanced Encryption Standard
* is a variant of Rijndael block cipher, standardized by NIST in 2001.
* We provide the fastest available pure JS implementation.
*
* Data is split into 128-bit blocks. Encrypted in 10/12/14 rounds (128/192/256 bits). In every round:
* 1. **S-box**, table substitution
* 2. **Shift rows**, cyclic shift left of all rows of data array
* 3. **Mix columns**, multiplying every column by fixed polynomial
* 4. **Add round key**, round_key xor i-th column of array
*
* Check out [FIPS-197](https://csrc.nist.gov/files/pubs/fips/197/final/docs/fips-197.pdf)
* and [original proposal](https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf)
* @module
*/
const _polyval_ts_1 = require("./_polyval.js");
// prettier-ignore
const utils_ts_1 = require("./utils.js");
const BLOCK_SIZE = 16;
const BLOCK_SIZE32 = 4;
const EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE);
const POLY = 0x11b; // 1 + x + x**3 + x**4 + x**8
// TODO: remove multiplication, binary ops only
function mul2(n) {
return (n << 1) ^ (POLY & -(n >> 7));
}
function mul(a, b) {
let res = 0;
for (; b > 0; b >>= 1) {
// Montgomery ladder
res ^= a & -(b & 1); // if (b&1) res ^=a (but const-time).
a = mul2(a); // a = 2*a
}
return res;
}
// AES S-box is generated using finite field inversion,
// an affine transform, and xor of a constant 0x63.
const sbox = /* @__PURE__ */ (() => {
const t = new Uint8Array(256);
for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))
t[i] = x;
const box = new Uint8Array(256);
box[0] = 0x63; // first elm
for (let i = 0; i < 255; i++) {
let x = t[255 - i];
x |= x << 8;
box[t[i]] = (x ^ (x >> 4) ^ (x >> 5) ^ (x >> 6) ^ (x >> 7) ^ 0x63) & 0xff;
}
(0, utils_ts_1.clean)(t);
return box;
})();
// Inverted S-box
const invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
// Rotate u32 by 8
const rotr32_8 = (n) => (n << 24) | (n >>> 8);
const rotl32_8 = (n) => (n << 8) | (n >>> 24);
// The byte swap operation for uint32 (LE<->BE)
const byteSwap = (word) => ((word << 24) & 0xff000000) |
((word << 8) & 0xff0000) |
((word >>> 8) & 0xff00) |
((word >>> 24) & 0xff);
// T-table is optimization suggested in 5.2 of original proposal (missed from FIPS-197). Changes:
// - LE instead of BE
// - bigger tables: T0 and T1 are merged into T01 table and T2 & T3 into T23;
// so index is u16, instead of u8. This speeds up things, unexpectedly
function genTtable(sbox, fn) {
if (sbox.length !== 256)
throw new Error('Wrong sbox length');
const T0 = new Uint32Array(256).map((_, j) => fn(sbox[j]));
const T1 = T0.map(rotl32_8);
const T2 = T1.map(rotl32_8);
const T3 = T2.map(rotl32_8);
const T01 = new Uint32Array(256 * 256);
const T23 = new Uint32Array(256 * 256);
const sbox2 = new Uint16Array(256 * 256);
for (let i = 0; i < 256; i++) {
for (let j = 0; j < 256; j++) {
const idx = i * 256 + j;
T01[idx] = T0[i] ^ T1[j];
T23[idx] = T2[i] ^ T3[j];
sbox2[idx] = (sbox[i] << 8) | sbox[j];
}
}
return { sbox, sbox2, T0, T1, T2, T3, T01, T23 };
}
const tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => (mul(s, 3) << 24) | (s << 16) | (s << 8) | mul(s, 2));
const tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => (mul(s, 11) << 24) | (mul(s, 13) << 16) | (mul(s, 9) << 8) | mul(s, 14));
const xPowers = /* @__PURE__ */ (() => {
const p = new Uint8Array(16);
for (let i = 0, x = 1; i < 16; i++, x = mul2(x))
p[i] = x;
return p;
})();
/** Key expansion used in CTR. */
function expandKeyLE(key) {
(0, utils_ts_1.abytes)(key);
const len = key.length;
if (![16, 24, 32].includes(len))
throw new Error('aes: invalid key size, should be 16, 24 or 32, got ' + len);
const { sbox2 } = tableEncoding;
const toClean = [];
if (!(0, utils_ts_1.isAligned32)(key))
toClean.push((key = (0, utils_ts_1.copyBytes)(key)));
const k32 = (0, utils_ts_1.u32)(key);
const Nk = k32.length;
const subByte = (n) => applySbox(sbox2, n, n, n, n);
const xk = new Uint32Array(len + 28); // expanded key
xk.set(k32);
// 4.3.1 Key expansion
for (let i = Nk; i < xk.length; i++) {
let t = xk[i - 1];
if (i % Nk === 0)
t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];
else if (Nk > 6 && i % Nk === 4)
t = subByte(t);
xk[i] = xk[i - Nk] ^ t;
}
(0, utils_ts_1.clean)(...toClean);
return xk;
}
function expandKeyDecLE(key) {
const encKey = expandKeyLE(key);
const xk = encKey.slice();
const Nk = encKey.length;
const { sbox2 } = tableEncoding;
const { T0, T1, T2, T3 } = tableDecoding;
// Inverse key by chunks of 4 (rounds)
for (let i = 0; i < Nk; i += 4) {
for (let j = 0; j < 4; j++)
xk[i + j] = encKey[Nk - i - 4 + j];
}
(0, utils_ts_1.clean)(encKey);
// apply InvMixColumn except first & last round
for (let i = 4; i < Nk - 4; i++) {
const x = xk[i];
const w = applySbox(sbox2, x, x, x, x);
xk[i] = T0[w & 0xff] ^ T1[(w >>> 8) & 0xff] ^ T2[(w >>> 16) & 0xff] ^ T3[w >>> 24];
}
return xk;
}
// Apply tables
function apply0123(T01, T23, s0, s1, s2, s3) {
return (T01[((s0 << 8) & 0xff00) | ((s1 >>> 8) & 0xff)] ^
T23[((s2 >>> 8) & 0xff00) | ((s3 >>> 24) & 0xff)]);
}
function applySbox(sbox2, s0, s1, s2, s3) {
return (sbox2[(s0 & 0xff) | (s1 & 0xff00)] |
(sbox2[((s2 >>> 16) & 0xff) | ((s3 >>> 16) & 0xff00)] << 16));
}
function encrypt(xk, s0, s1, s2, s3) {
const { sbox2, T01, T23 } = tableEncoding;
let k = 0;
(s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);
const rounds = xk.length / 4 - 2;
for (let i = 0; i < rounds; i++) {
const t0 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
const t1 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
const t2 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
const t3 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
(s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3);
}
// last round (without mixcolumns, so using SBOX2 table)
const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
return { s0: t0, s1: t1, s2: t2, s3: t3 };
}
// Can't be merged with encrypt: arg positions for apply0123 / applySbox are different
function decrypt(xk, s0, s1, s2, s3) {
const { sbox2, T01, T23 } = tableDecoding;
let k = 0;
(s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]);
const rounds = xk.length / 4 - 2;
for (let i = 0; i < rounds; i++) {
const t0 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);
const t1 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);
const t2 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);
const t3 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);
(s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3);
}
// Last round
const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);
const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);
const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);
const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);
return { s0: t0, s1: t1, s2: t2, s3: t3 };
}
// TODO: investigate merging with ctr32
function ctrCounter(xk, nonce, src, dst) {
(0, utils_ts_1.abytes)(nonce, BLOCK_SIZE);
(0, utils_ts_1.abytes)(src);
const srcLen = src.length;
dst = (0, utils_ts_1.getOutput)(srcLen, dst);
(0, utils_ts_1.complexOverlapBytes)(src, dst);
const ctr = nonce;
const c32 = (0, utils_ts_1.u32)(ctr);
// Fill block (empty, ctr=0)
let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);
const src32 = (0, utils_ts_1.u32)(src);
const dst32 = (0, utils_ts_1.u32)(dst);
// process blocks
for (let i = 0; i + 4 <= src32.length; i += 4) {
dst32[i + 0] = src32[i + 0] ^ s0;
dst32[i + 1] = src32[i + 1] ^ s1;
dst32[i + 2] = src32[i + 2] ^ s2;
dst32[i + 3] = src32[i + 3] ^ s3;
// Full 128 bit counter with wrap around
let carry = 1;
for (let i = ctr.length - 1; i >= 0; i--) {
carry = (carry + (ctr[i] & 0xff)) | 0;
ctr[i] = carry & 0xff;
carry >>>= 8;
}
({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));
}
// leftovers (less than block)
// It's possible to handle > u32 fast, but is it worth it?
const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
if (start < srcLen) {
const b32 = new Uint32Array([s0, s1, s2, s3]);
const buf = (0, utils_ts_1.u8)(b32);
for (let i = start, pos = 0; i < srcLen; i++, pos++)
dst[i] = src[i] ^ buf[pos];
(0, utils_ts_1.clean)(b32);
}
return dst;
}
// AES CTR with overflowing 32 bit counter
// It's possible to do 32le significantly simpler (and probably faster) by using u32.
// But, we need both, and perf bottleneck is in ghash anyway.
function ctr32(xk, isLE, nonce, src, dst) {
(0, utils_ts_1.abytes)(nonce, BLOCK_SIZE);
(0, utils_ts_1.abytes)(src);
dst = (0, utils_ts_1.getOutput)(src.length, dst);
const ctr = nonce; // write new value to nonce, so it can be re-used
const c32 = (0, utils_ts_1.u32)(ctr);
const view = (0, utils_ts_1.createView)(ctr);
const src32 = (0, utils_ts_1.u32)(src);
const dst32 = (0, utils_ts_1.u32)(dst);
const ctrPos = isLE ? 0 : 12;
const srcLen = src.length;
// Fill block (empty, ctr=0)
let ctrNum = view.getUint32(ctrPos, isLE); // read current counter value
let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);
// process blocks
for (let i = 0; i + 4 <= src32.length; i += 4) {
dst32[i + 0] = src32[i + 0] ^ s0;
dst32[i + 1] = src32[i + 1] ^ s1;
dst32[i + 2] = src32[i + 2] ^ s2;
dst32[i + 3] = src32[i + 3] ^ s3;
ctrNum = (ctrNum + 1) >>> 0; // u32 wrap
view.setUint32(ctrPos, ctrNum, isLE);
({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));
}
// leftovers (less than a block)
const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
if (start < srcLen) {
const b32 = new Uint32Array([s0, s1, s2, s3]);
const buf = (0, utils_ts_1.u8)(b32);
for (let i = start, pos = 0; i < srcLen; i++, pos++)
dst[i] = src[i] ^ buf[pos];
(0, utils_ts_1.clean)(b32);
}
return dst;
}
/**
* CTR: counter mode. Creates stream cipher.
* Requires good IV. Parallelizable. OK, but no MAC.
*/
exports.ctr = (0, utils_ts_1.wrapCipher)({ blockSize: 16, nonceLength: 16 }, function aesctr(key, nonce) {
function processCtr(buf, dst) {
(0, utils_ts_1.abytes)(buf);
if (dst !== undefined) {
(0, utils_ts_1.abytes)(dst);
if (!(0, utils_ts_1.isAligned32)(dst))
throw new Error('unaligned destination');
}
const xk = expandKeyLE(key);
const n = (0, utils_ts_1.copyBytes)(nonce); // align + avoid changing
const toClean = [xk, n];
if (!(0, utils_ts_1.isAligned32)(buf))
toClean.push((buf = (0, utils_ts_1.copyBytes)(buf)));
const out = ctrCounter(xk, n, buf, dst);
(0, utils_ts_1.clean)(...toClean);
return out;
}
return {
encrypt: (plaintext, dst) => processCtr(plaintext, dst),
decrypt: (ciphertext, dst) => processCtr(ciphertext, dst),
};
});
function validateBlockDecrypt(data) {
(0, utils_ts_1.abytes)(data);
if (data.length % BLOCK_SIZE !== 0) {
throw new Error('aes-(cbc/ecb).decrypt ciphertext should consist of blocks with size ' + BLOCK_SIZE);
}
}
function validateBlockEncrypt(plaintext, pcks5, dst) {
(0, utils_ts_1.abytes)(plaintext);
let outLen = plaintext.length;
const remaining = outLen % BLOCK_SIZE;
if (!pcks5 && remaining !== 0)
throw new Error('aec/(cbc-ecb): unpadded plaintext with disabled padding');
if (!(0, utils_ts_1.isAligned32)(plaintext))
plaintext = (0, utils_ts_1.copyBytes)(plaintext);
const b = (0, utils_ts_1.u32)(plaintext);
if (pcks5) {
let left = BLOCK_SIZE - remaining;
if (!left)
left = BLOCK_SIZE; // if no bytes left, create empty padding block
outLen = outLen + left;
}
dst = (0, utils_ts_1.getOutput)(outLen, dst);
(0, utils_ts_1.complexOverlapBytes)(plaintext, dst);
const o = (0, utils_ts_1.u32)(dst);
return { b, o, out: dst };
}
function validatePCKS(data, pcks5) {
if (!pcks5)
return data;
const len = data.length;
if (!len)
throw new Error('aes/pcks5: empty ciphertext not allowed');
const lastByte = data[len - 1];
if (lastByte <= 0 || lastByte > 16)
throw new Error('aes/pcks5: wrong padding');
const out = data.subarray(0, -lastByte);
for (let i = 0; i < lastByte; i++)
if (data[len - i - 1] !== lastByte)
throw new Error('aes/pcks5: wrong padding');
return out;
}
function padPCKS(left) {
const tmp = new Uint8Array(16);
const tmp32 = (0, utils_ts_1.u32)(tmp);
tmp.set(left);
const paddingByte = BLOCK_SIZE - left.length;
for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)
tmp[i] = paddingByte;
return tmp32;
}
/**
* ECB: Electronic CodeBook. Simple deterministic replacement.
* Dangerous: always map x to y. See [AES Penguin](https://words.filippo.io/the-ecb-penguin/).
*/
exports.ecb = (0, utils_ts_1.wrapCipher)({ blockSize: 16 }, function aesecb(key, opts = {}) {
const pcks5 = !opts.disablePadding;
return {
encrypt(plaintext, dst) {
const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);
const xk = expandKeyLE(key);
let i = 0;
for (; i + 4 <= b.length;) {
const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);
(o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);
}
if (pcks5) {
const tmp32 = padPCKS(plaintext.subarray(i * 4));
const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);
(o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);
}
(0, utils_ts_1.clean)(xk);
return _out;
},
decrypt(ciphertext, dst) {
validateBlockDecrypt(ciphertext);
const xk = expandKeyDecLE(key);
dst = (0, utils_ts_1.getOutput)(ciphertext.length, dst);
const toClean = [xk];
if (!(0, utils_ts_1.isAligned32)(ciphertext))
toClean.push((ciphertext = (0, utils_ts_1.copyBytes)(ciphertext)));
(0, utils_ts_1.complexOverlapBytes)(ciphertext, dst);
const b = (0, utils_ts_1.u32)(ciphertext);
const o = (0, utils_ts_1.u32)(dst);
for (let i = 0; i + 4 <= b.length;) {
const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);
(o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);
}
(0, utils_ts_1.clean)(...toClean);
return validatePCKS(dst, pcks5);
},
};
});
/**
* CBC: Cipher-Block-Chaining. Key is previous round’s block.
* Fragile: needs proper padding. Unauthenticated: needs MAC.
*/
exports.cbc = (0, utils_ts_1.wrapCipher)({ blockSize: 16, nonceLength: 16 }, function aescbc(key, iv, opts = {}) {
const pcks5 = !opts.disablePadding;
return {
encrypt(plaintext, dst) {
const xk = expandKeyLE(key);
const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);
let _iv = iv;
const toClean = [xk];
if (!(0, utils_ts_1.isAligned32)(_iv))
toClean.push((_iv = (0, utils_ts_1.copyBytes)(_iv)));
const n32 = (0, utils_ts_1.u32)(_iv);
// prettier-ignore
let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
let i = 0;
for (; i + 4 <= b.length;) {
(s0 ^= b[i + 0]), (s1 ^= b[i + 1]), (s2 ^= b[i + 2]), (s3 ^= b[i + 3]);
({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
(o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);
}
if (pcks5) {
const tmp32 = padPCKS(plaintext.subarray(i * 4));
(s0 ^= tmp32[0]), (s1 ^= tmp32[1]), (s2 ^= tmp32[2]), (s3 ^= tmp32[3]);
({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
(o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3);
}
(0, utils_ts_1.clean)(...toClean);
return _out;
},
decrypt(ciphertext, dst) {
validateBlockDecrypt(ciphertext);
const xk = expandKeyDecLE(key);
let _iv = iv;
const toClean = [xk];
if (!(0, utils_ts_1.isAligned32)(_iv))
toClean.push((_iv = (0, utils_ts_1.copyBytes)(_iv)));
const n32 = (0, utils_ts_1.u32)(_iv);
dst = (0, utils_ts_1.getOutput)(ciphertext.length, dst);
if (!(0, utils_ts_1.isAligned32)(ciphertext))
toClean.push((ciphertext = (0, utils_ts_1.copyBytes)(ciphertext)));
(0, utils_ts_1.complexOverlapBytes)(ciphertext, dst);
const b = (0, utils_ts_1.u32)(ciphertext);
const o = (0, utils_ts_1.u32)(dst);
// prettier-ignore
let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
for (let i = 0; i + 4 <= b.length;) {
// prettier-ignore
const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;
(s0 = b[i + 0]), (s1 = b[i + 1]), (s2 = b[i + 2]), (s3 = b[i + 3]);
const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);
(o[i++] = o0 ^ ps0), (o[i++] = o1 ^ ps1), (o[i++] = o2 ^ ps2), (o[i++] = o3 ^ ps3);
}
(0, utils_ts_1.clean)(...toClean);
return validatePCKS(dst, pcks5);
},
};
});
/**
* CFB: Cipher Feedback Mode. The input for the block cipher is the previous cipher output.
* Unauthenticated: needs MAC.
*/
exports.cfb = (0, utils_ts_1.wrapCipher)({ blockSize: 16, nonceLength: 16 }, function aescfb(key, iv) {
function processCfb(src, isEncrypt, dst) {
(0, utils_ts_1.abytes)(src);
const srcLen = src.length;
dst = (0, utils_ts_1.getOutput)(srcLen, dst);
if ((0, utils_ts_1.overlapBytes)(src, dst))
throw new Error('overlapping src and dst not supported.');
const xk = expandKeyLE(key);
let _iv = iv;
const toClean = [xk];
if (!(0, utils_ts_1.isAligned32)(_iv))
toClean.push((_iv = (0, utils_ts_1.copyBytes)(_iv)));
if (!(0, utils_ts_1.isAligned32)(src))
toClean.push((src = (0, utils_ts_1.copyBytes)(src)));
const src32 = (0, utils_ts_1.u32)(src);
const dst32 = (0, utils_ts_1.u32)(dst);
const next32 = isEncrypt ? dst32 : src32;
const n32 = (0, utils_ts_1.u32)(_iv);
// prettier-ignore
let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
for (let i = 0; i + 4 <= src32.length;) {
const { s0: e0, s1: e1, s2: e2, s3: e3 } = encrypt(xk, s0, s1, s2, s3);
dst32[i + 0] = src32[i + 0] ^ e0;
dst32[i + 1] = src32[i + 1] ^ e1;
dst32[i + 2] = src32[i + 2] ^ e2;
dst32[i + 3] = src32[i + 3] ^ e3;
(s0 = next32[i++]), (s1 = next32[i++]), (s2 = next32[i++]), (s3 = next32[i++]);
}
// leftovers (less than block)
const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);
if (start < srcLen) {
({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
const buf = (0, utils_ts_1.u8)(new Uint32Array([s0, s1, s2, s3]));
for (let i = start, pos = 0; i < srcLen; i++, pos++)
dst[i] = src[i] ^ buf[pos];
(0, utils_ts_1.clean)(buf);
}
(0, utils_ts_1.clean)(...toClean);
return dst;
}
return {
encrypt: (plaintext, dst) => processCfb(plaintext, true, dst),
decrypt: (ciphertext, dst) => processCfb(ciphertext, false, dst),
};
});
// TODO: merge with chacha, however gcm has bitLen while chacha has byteLen
function computeTag(fn, isLE, key, data, AAD) {
const aadLength = AAD ? AAD.length : 0;
const h = fn.create(key, data.length + aadLength);
if (AAD)
h.update(AAD);
const num = (0, utils_ts_1.u64Lengths)(8 * data.length, 8 * aadLength, isLE);
h.update(data);
h.update(num);
const res = h.digest();
(0, utils_ts_1.clean)(num);
return res;
}
/**
* GCM: Galois/Counter Mode.
* Modern, parallel version of CTR, with MAC.
* Be careful: MACs can be forged.
* Unsafe to use random nonces under the same key, due to collision chance.
* As for nonce size, prefer 12-byte, instead of 8-byte.
*/
exports.gcm = (0, utils_ts_1.wrapCipher)({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {
// NIST 800-38d doesn't enforce minimum nonce length.
// We enforce 8 bytes for compat with openssl.
// 12 bytes are recommended. More than 12 bytes would be converted into 12.
if (nonce.length < 8)
throw new Error('aes/gcm: invalid nonce length');
const tagLength = 16;
function _computeTag(authKey, tagMask, data) {
const tag = computeTag(_polyval_ts_1.ghash, false, authKey, data, AAD);
for (let i = 0; i < tagMask.length; i++)
tag[i] ^= tagMask[i];
return tag;
}
function deriveKeys() {
const xk = expandKeyLE(key);
const authKey = EMPTY_BLOCK.slice();
const counter = EMPTY_BLOCK.slice();
ctr32(xk, false, counter, counter, authKey);
// NIST 800-38d, page 15: different behavior for 96-bit and non-96-bit nonces
if (nonce.length === 12) {
counter.set(nonce);
}
else {
const nonceLen = EMPTY_BLOCK.slice();
const view = (0, utils_ts_1.createView)(nonceLen);
(0, utils_ts_1.setBigUint64)(view, 8, BigInt(nonce.length * 8), false);
// ghash(nonce || u64be(0) || u64be(nonceLen*8))
const g = _polyval_ts_1.ghash.create(authKey).update(nonce).update(nonceLen);
g.digestInto(counter); // digestInto doesn't trigger '.destroy'
g.destroy();
}
const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);
return { xk, authKey, counter, tagMask };
}
return {
encrypt(plaintext) {
const { xk, authKey, counter, tagMask } = deriveKeys();
const out = new Uint8Array(plaintext.length + tagLength);
const toClean = [xk, authKey, counter, tagMask];
if (!(0, utils_ts_1.isAligned32)(plaintext))
toClean.push((plaintext = (0, utils_ts_1.copyBytes)(plaintext)));
ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));
const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));
toClean.push(tag);
out.set(tag, plaintext.length);
(0, utils_ts_1.clean)(...toClean);
return out;
},
decrypt(ciphertext) {
const { xk, authKey, counter, tagMask } = deriveKeys();
const toClean = [xk, authKey, tagMask, counter];
if (!(0, utils_ts_1.isAligned32)(ciphertext))
toClean.push((ciphertext = (0, utils_ts_1.copyBytes)(ciphertext)));
const data = ciphertext.subarray(0, -tagLength);
const passedTag = ciphertext.subarray(-tagLength);
const tag = _computeTag(authKey, tagMask, data);
toClean.push(tag);
if (!(0, utils_ts_1.equalBytes)(tag, passedTag))
throw new Error('aes/gcm: invalid ghash tag');
const out = ctr32(xk, false, counter, data);
(0, utils_ts_1.clean)(...toClean);
return out;
},
};
});
const limit = (name, min, max) => (value) => {
if (!Number.isSafeInteger(value) || min > value || value > max) {
const minmax = '[' + min + '..' + max + ']';
throw new Error('' + name + ': expected value in range ' + minmax + ', got ' + value);
}
};
/**
* AES-GCM-SIV: classic AES-GCM with nonce-misuse resistance.
* Guarantees that, when a nonce is repeated, the only security loss is that identical
* plaintexts will produce identical ciphertexts.
* RFC 8452, https://datatracker.ietf.org/doc/html/rfc8452
*/
exports.gcmsiv = (0, utils_ts_1.wrapCipher)({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aessiv(key, nonce, AAD) {
const tagLength = 16;
// From RFC 8452: Section 6
const AAD_LIMIT = limit('AAD', 0, 2 ** 36);
const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 36);
const NONCE_LIMIT = limit('nonce', 12, 12);
const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 36 + 16);
(0, utils_ts_1.abytes)(key, 16, 24, 32);
NONCE_LIMIT(nonce.length);
if (AAD !== undefined)
AAD_LIMIT(AAD.length);
function deriveKeys() {
const xk = expandKeyLE(key);
const encKey = new Uint8Array(key.length);
const authKey = new Uint8Array(16);
const toClean = [xk, encKey];
let _nonce = nonce;
if (!(0, utils_ts_1.isAligned32)(_nonce))
toClean.push((_nonce = (0, utils_ts_1.copyBytes)(_nonce)));
const n32 = (0, utils_ts_1.u32)(_nonce);
// prettier-ignore
let s0 = 0, s1 = n32[0], s2 = n32[1], s3 = n32[2];
let counter = 0;
for (const derivedKey of [authKey, encKey].map(utils_ts_1.u32)) {
const d32 = (0, utils_ts_1.u32)(derivedKey);
for (let i = 0; i < d32.length; i += 2) {
// aes(u32le(0) || nonce)[:8] || aes(u32le(1) || nonce)[:8] ...
const { s0: o0, s1: o1 } = encrypt(xk, s0, s1, s2, s3);
d32[i + 0] = o0;
d32[i + 1] = o1;
s0 = ++counter; // increment counter inside state
}
}
const res = { authKey, encKey: expandKeyLE(encKey) };
// Cleanup
(0, utils_ts_1.clean)(...toClean);
return res;
}
function _computeTag(encKey, authKey, data) {
const tag = computeTag(_polyval_ts_1.polyval, true, authKey, data, AAD);
// Compute the expected tag by XORing S_s and the nonce, clearing the
// most significant bit of the last byte and encrypting with the
// message-encryption key.
for (let i = 0; i < 12; i++)
tag[i] ^= nonce[i];
tag[15] &= 0x7f; // Clear the highest bit
// encrypt tag as block
const t32 = (0, utils_ts_1.u32)(tag);
// prettier-ignore
let s0 = t32[0], s1 = t32[1], s2 = t32[2], s3 = t32[3];
({ s0, s1, s2, s3 } = encrypt(encKey, s0, s1, s2, s3));
(t32[0] = s0), (t32[1] = s1), (t32[2] = s2), (t32[3] = s3);
return tag;
}
// actual decrypt/encrypt of message.
function processSiv(encKey, tag, input) {
let block = (0, utils_ts_1.copyBytes)(tag);
block[15] |= 0x80; // Force highest bit
const res = ctr32(encKey, true, block, input);
// Cleanup
(0, utils_ts_1.clean)(block);
return res;
}
return {
encrypt(plaintext) {
PLAIN_LIMIT(plaintext.length);
const { encKey, authKey } = deriveKeys();
const tag = _computeTag(encKey, authKey, plaintext);
const toClean = [encKey, authKey, tag];
if (!(0, utils_ts_1.isAligned32)(plaintext))
toClean.push((plaintext = (0, utils_ts_1.copyBytes)(plaintext)));
const out = new Uint8Array(plaintext.length + tagLength);
out.set(tag, plaintext.length);
out.set(processSiv(encKey, tag, plaintext));
// Cleanup
(0, utils_ts_1.clean)(...toClean);
return out;
},
decrypt(ciphertext) {
CIPHER_LIMIT(ciphertext.length);
const tag = ciphertext.subarray(-tagLength);
const { encKey, authKey } = deriveKeys();
const toClean = [encKey, authKey];
if (!(0, utils_ts_1.isAligned32)(ciphertext))
toClean.push((ciphertext = (0, utils_ts_1.copyBytes)(ciphertext)));
const plaintext = processSiv(encKey, tag, ciphertext.subarray(0, -tagLength));
const expectedTag = _computeTag(encKey, authKey, plaintext);
toClean.push(expectedTag);
if (!(0, utils_ts_1.equalBytes)(tag, expectedTag)) {
(0, utils_ts_1.clean)(...toClean);
throw new Error('invalid polyval tag');
}
// Cleanup
(0, utils_ts_1.clean)(...toClean);
return plaintext;
},
};
});
/**
* AES-GCM-SIV, not AES-SIV.
* This is legace name, use `gcmsiv` export instead.
* @deprecated
*/
exports.siv = exports.gcmsiv;
function isBytes32(a) {
return (a instanceof Uint32Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint32Array'));
}
function encryptBlock(xk, block) {
(0, utils_ts_1.abytes)(block, 16);
if (!isBytes32(xk))
throw new Error('_encryptBlock accepts result of expandKeyLE');
const b32 = (0, utils_ts_1.u32)(block);
let { s0, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);
(b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3);
return block;
}
function decryptBlock(xk, block) {
(0, utils_ts_1.abytes)(block, 16);
if (!isBytes32(xk))
throw new Error('_decryptBlock accepts result of expandKeyLE');
const b32 = (0, utils_ts_1.u32)(block);
let { s0, s1, s2, s3 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);
(b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3);
return block;
}
/**
* AES-W (base for AESKW/AESKWP).
* Specs: [SP800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf),
* [RFC 3394](https://datatracker.ietf.org/doc/rfc3394/),
* [RFC 5649](https://datatracker.ietf.org/doc/rfc5649/).
*/
const AESW = {
/*
High-level pseudocode:
```
A: u64 = IV
out = []
for (let i=0, ctr = 0; i<6; i++) {
for (const chunk of chunks(plaintext, 8)) {
A ^= swapEndianess(ctr++)
[A, res] = chunks(encrypt(A || chunk), 8);
out ||= res
}
}
out = A || out
```
Decrypt is the same, but reversed.
*/
encrypt(kek, out) {
// Size is limited to 4GB, otherwise ctr will overflow and we'll need to switch to bigints.
// If you need it larger, open an issue.
if (out.length >= 2 ** 32)
throw new Error('plaintext should be less than 4gb');
const xk = expandKeyLE(kek);
if (out.length === 16)
encryptBlock(xk, out);
else {
const o32 = (0, utils_ts_1.u32)(out);
// prettier-ignore
let a0 = o32[0], a1 = o32[1]; // A
for (let j = 0, ctr = 1; j < 6; j++) {
for (let pos = 2; pos < o32.length; pos += 2, ctr++) {
const { s0, s1, s2, s3 } = encrypt(xk, a0, a1, o32[pos], o32[pos + 1]);
// A = MSB(64, B) ^ t where t = (n*j)+i
(a0 = s0), (a1 = s1 ^ byteSwap(ctr)), (o32[pos] = s2), (o32[pos + 1] = s3);
}
}
(o32[0] = a0), (o32[1] = a1); // out = A || out
}
xk.fill(0);
},
decrypt(kek, out) {
if (out.length - 8 >= 2 ** 32)
throw new Error('ciphertext should be less than 4gb');
const xk = expandKeyDecLE(kek);
const chunks = out.length / 8 - 1; // first chunk is IV
if (chunks === 1)
decryptBlock(xk, out);
else {
const o32 = (0, utils_ts_1.u32)(out);
// prettier-ignore
let a0 = o32[0], a1 = o32[1]; // A
for (let j = 0, ctr = chunks * 6; j < 6; j++) {
for (let pos = chunks * 2; pos >= 1; pos -= 2, ctr--) {
a1 ^= byteSwap(ctr);
const { s0, s1, s2, s3 } = decrypt(xk, a0, a1, o32[pos], o32[pos + 1]);
(a0 = s0), (a1 = s1), (o32[pos] = s2), (o32[pos + 1] = s3);
}
}
(o32[0] = a0), (o32[1] = a1);
}
xk.fill(0);
},
};
const AESKW_IV = /* @__PURE__ */ new Uint8Array(8).fill(0xa6); // A6A6A6A6A6A6A6A6
/**
* AES-KW (key-wrap). Injects static IV into plaintext, adds counter, encrypts 6 times.
* Reduces block size from 16 to 8 bytes.
* For padded version, use aeskwp.
* [RFC 3394](https://datatracker.ietf.org/doc/rfc3394/),
* [NIST.SP.800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf).
*/
exports.aeskw = (0, utils_ts_1.wrapCipher)({ blockSize: 8 }, (kek) => ({
encrypt(plaintext) {
if (!plaintext.length || plaintext.length % 8 !== 0)
throw new Error('invalid plaintext length');
if (plaintext.length === 8)
throw new Error('8-byte keys not allowed in AESKW, use AESKWP instead');
const out = (0, utils_ts_1.concatBytes)(AESKW_IV, plaintext);
AESW.encrypt(kek, out);
return out;
},
decrypt(ciphertext) {
// ciphertext must be at least 24 bytes and a multiple of 8 bytes
// 24 because should have at least two block (1 iv + 2).
// Replace with 16 to enable '8-byte keys'
if (ciphertext.length % 8 !== 0 || ciphertext.length < 3 * 8)
throw new Error('invalid ciphertext length');
const out = (0, utils_ts_1.copyBytes)(ciphertext);
AESW.decrypt(kek, out);
if (!(0, utils_ts_1.equalBytes)(out.subarray(0, 8), AESKW_IV))
throw new Error('integrity check failed');
out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway
return out.subarray(8);
},
}));
/*
We don't support 8-byte keys. The rabbit hole:
- Wycheproof says: "NIST SP 800-38F does not define the wrapping of 8 byte keys.
RFC 3394 Section 2 on the other hand specifies that 8 byte keys are wrapped
by directly encrypting one block with AES."
- https://github.com/C2SP/wycheproof/blob/master/doc/key_wrap.md
- "RFC 3394 specifies in Section 2, that the input for the key wrap
algorithm must be at least two blocks and otherwise the constant
field and key are simply encrypted with ECB as a single block"
- What RFC 3394 actually says (in Section 2):
- "Before being wrapped, the key data is parsed into n blocks of 64 bits.
The only restriction the key wrap algorithm places on n is that n be
at least two"
- "For key data with length less than or equal to 64 bits, the constant
field used in this specification and the key data form a single
128-bit codebook input making this key wrap unnecessary."
- Which means "assert(n >= 2)" and "use something else for 8 byte keys"
- NIST SP800-38F actually prohibits 8-byte in "5.3.1 Mandatory Limits".
It states that plaintext for KW should be "2 to 2^54 -1 semiblocks".
- So, where does "directly encrypt single block with AES" come from?
- Not RFC 3394. Pseudocode of key wrap in 2.2 explicitly uses
loop of 6 for any code path
- There is a weird W3C spec:
https://www.w3.org/TR/2002/REC-xmlenc-core-20021210/Overview.html#kw-aes128
- This spec is outdated, as admitted by Wycheproof authors
- There is RFC 5649 for padded key wrap, which is padding construction on
top of AESKW. In '4.1.2' it says: "If the padded plaintext contains exactly
eight octets, then prepend the AIV as defined in Section 3 above to P[1] and
encrypt the resulting 128-bit block using AES in ECB mode [Modes] with key
K (the KEK). In this case, the output is two 64-bit blocks C[0] and C[1]:"
- Browser subtle crypto is actually crashes on wrapping keys less than 16 bytes:
`Error: error:1C8000E6:Provider routines::invalid input length] { opensslErrorStack: [ 'error:030000BD:digital envelope routines::update error' ]`
In the end, seems like a bug in Wycheproof.
The 8-byte check can be easily disabled inside of AES_W.
*/
const AESKWP_IV = 0xa65959a6; // single u32le value
/**
* AES-KW, but with padding and allows random keys.
* Second u32 of IV is used as counter for length.
* [RFC 5649](https://www.rfc-editor.org/rfc/rfc5649)
*/
exports.aeskwp = (0, utils_ts_1.wrapCipher)({ blockSize: 8 }, (kek) => ({
encrypt(plaintext) {
if (!plaintext.length)
throw new Error('invalid plaintext length');
const padded = Math.ceil(plaintext.length / 8) * 8;
const out = new Uint8Array(8 + padded);
out.set(plaintext, 8);
const out32 = (0, utils_ts_1.u32)(out);
out32[0] = AESKWP_IV;
out32[1] = byteSwap(plaintext.length);
AESW.encrypt(kek, out);
return out;
},
decrypt(ciphertext) {
// 16 because should have at least one block
if (ciphertext.length < 16)
throw new Error('invalid ciphertext length');
const out = (0, utils_ts_1.copyBytes)(ciphertext);
const o32 = (0, utils_ts_1.u32)(out);
AESW.decrypt(kek, out);
const len = byteSwap(o32[1]) >>> 0;
const padded = Math.ceil(len / 8) * 8;
if (o32[0] !== AESKWP_IV || out.length - 8 !== padded)
throw new Error('integrity check failed');
for (let i = len; i < padded; i++)
if (out[8 + i] !== 0)
throw new Error('integrity check failed');
out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway
return out.subarray(8, 8 + len);
},
}));
/** Unsafe low-level internal methods. May change at any time. */
exports.unsafe = {
expandKeyLE,
expandKeyDecLE,
encrypt,
decrypt,
encryptBlock,
decryptBlock,
ctrCounter,
ctr32,
};
},{"./_polyval.js":2,"./utils.js":4}],4:[function(require,module,exports){
"use strict";
/**
* Utilities for hex, bytes, CSPRNG.
* @module
*/
/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
Object.defineProperty(exports, "__esModule", { value: true });
exports.wrapCipher = exports.Hash = exports.nextTick = exports.isLE = void 0;
exports.isBytes = isBytes;
exports.abool = abool;
exports.anumber = anumber;
exports.abytes = abytes;
exports.ahash = ahash;
exports.aexists = aexists;
exports.aoutput = aoutput;
exports.u8 = u8;
exports.u32 = u32;
exports.clean = clean;
exports.createView = createView;
exports.bytesToHex = bytesToHex;
exports.hexToBytes = hexToBytes;
exports.hexToNumber = hexToNumber;
exports.bytesToNumberBE = bytesToNumberBE;
exports.numberToBytesBE = numberToBytesBE;
exports.utf8ToBytes = utf8ToBytes;
exports.bytesToUtf8 = bytesToUtf8;
exports.toBytes = toBytes;
exports.overlapBytes = overlapBytes;
exports.complexOverlapBytes = complexOverlapBytes;
exports.concatBytes = concatBytes;
exports.checkOpts = checkOpts;
exports.equalBytes = equalBytes;
exports.getOutput = getOutput;
exports.setBigUint64 = setBigUint64;
exports.u64Lengths = u64Lengths;
exports.isAligned32 = isAligned32;
exports.copyBytes = copyBytes;
/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
function isBytes(a) {
return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
}
/** Asserts something is boolean. */
function abool(b) {
if (typeof b !== 'boolean')
throw new Error(`boolean expected, not ${b}`);
}
/** Asserts something is positive integer. */
function anumber(n) {
if (!Number.isSafeInteger(n) || n < 0)
throw new Error('positive integer expected, got ' + n);
}
/** Asserts something is Uint8Array. */
function abytes(b, ...lengths) {
if (!isBytes(b))
throw new Error('Uint8Array expected');
if (lengths.length > 0 && !lengths.includes(b.length))
throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
}
/**
* Asserts something is hash
* TODO: remove
* @deprecated
*/
function ahash(h) {
if (typeof h !== 'function' || typeof h.create !== 'function')
throw new Error('Hash should be wrapped by utils.createHasher');
anumber(h.outputLen);
anumber(h.blockLen);
}
/** Asserts a hash instance has not been destroyed / finished */
function aexists(instance, checkFinished = true) {
if (instance.destroyed)
throw new Error('Hash instance has been destroyed');
if (checkFinished && instance.finished)
throw new Error('Hash#digest() has already been called');
}
/** Asserts output is properly-sized byte array */
function aoutput(out, instance) {
abytes(out);
const min = instance.outputLen;
if (out.length < min) {
throw new Error('digestInto() expects output buffer of length at least ' + min);
}
}
/** Cast u8 / u16 / u32 to u8. */
function u8(arr) {
return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
}
/** Cast u8 / u16 / u32 to u32. */
function u32(arr) {
return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
}
/** Zeroize a byte array. Warning: JS provides no guarantees. */
function clean(...arrays) {
for (let i = 0; i < arrays.length; i++) {
arrays[i].fill(0);
}
}
/** Create DataView of an array for easy byte-level manipulation. */
function createView(arr) {
return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
}
/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
exports.isLE = (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
const hasHexBuiltin = /* @__PURE__ */ (() =>
// @ts-ignore
typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
// Array where index 0xf0 (240) is mapped to string 'f0'
const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
/**
* Convert byte array to hex string. Uses built-in function, when available.
* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
*/
function bytesToHex(bytes) {
abytes(bytes);
// @ts-ignore
if (hasHexBuiltin)
return bytes.toHex();
// pre-caching improves the speed 6x
let hex = '';
for (let i = 0; i < bytes.length; i++) {
hex += hexes[bytes[i]];
}
return hex;
}
// We use optimized technique to convert hex string to byte array
const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
function asciiToBase16(ch) {
if (ch >= asciis._0 && ch <= asciis._9)
return ch - asciis._0; // '2' => 50-48
if (ch >= asciis.A && ch <= asciis.F)
return ch - (asciis.A - 10); // 'B' => 66-(65-10)
if (ch >= asciis.a && ch <= asciis.f)
return ch - (asciis.a - 10); // 'b' => 98-(97-10)
return;
}
/**
* Convert hex string to byte array. Uses built-in function, when available.
* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
*/
function hexToBytes(hex) {
if (typeof hex !== 'string')
throw new Error('hex string expected, got ' + typeof hex);
// @ts-ignore
if (hasHexBuiltin)
return Uint8Array.fromHex(hex);
const hl = hex.length;
const al = hl / 2;
if (hl % 2)
throw new Error('hex string expected, got unpadded hex of length ' + hl);
const array = new Uint8Array(al);
for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
const n1 = asciiToBase16(hex.charCodeAt(hi));
const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
if (n1 === undefined || n2 === undefined) {
const char = hex[hi] + hex[hi + 1];
throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
}
array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
}
return array;
}
// Used in micro
function hexToNumber(hex) {
if (typeof hex !== 'string')
throw new Error('hex string expected, got ' + typeof hex);
return BigInt(hex === '' ? '0' : '0x' + hex); // Big Endian
}
// Used in ff1
// BE: Big Endian, LE: Little Endian
function bytesToNumberBE(bytes) {
return hexToNumber(bytesToHex(bytes));
}
// Used in micro, ff1
function numberToBytesBE(n, len) {
return hexToBytes(n.toString(16).padStart(len * 2, '0'));
}
// TODO: remove
// There is no setImmediate in browser and setTimeout is slow.
// call of async fn will return Promise, which will be fullfiled only on
// next scheduler queue processing step and this is exactly what we need.
const nextTick = async () => { };
exports.nextTick = nextTick;
/**
* Converts string to bytes using UTF8 encoding.
* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
*/
function utf8ToBytes(str) {
if (typeof str !== 'string')
throw new Error('string expected');
return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
}
/**
* Converts bytes to string using UTF8 encoding.
* @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'
*/
function bytesToUtf8(bytes) {
return new TextDecoder().decode(bytes);
}
/**
* Normalizes (non-hex) string or Uint8Array to Uint8Array.
* Warning: when Uint8Array is passed, it would NOT get copied.
* Keep in mind for future mutable operations.
*/
function toBytes(data) {
if (typeof data === 'string')
data = utf8ToBytes(data);
else if (isBytes(data))
data = copyBytes(data);
else
throw new Error('Uint8Array expected, got ' + typeof data);
return data;
}
/**
* Checks if two U8A use same underlying buffer and overlaps.
* This is invalid and can corrupt data.
*/
function overlapBytes(a, b) {
return (a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy
a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end
b.byteOffset < a.byteOffset + a.byteLength // b starts before a end
);
}
/**
* If input and output overlap and input starts before output, we will overwrite end of input before
* we start processing it, so this is not supported for most ciphers (except chacha/salse, which designed with this)
*/
function complexOverlapBytes(input, output) {
// This is very cursed. It works somehow, but I'm completely unsure,
// reasoning about overlapping aligned windows is very hard.
if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)
throw new Error('complex overlap of input and output is not supported');
}
/**
* Copies several Uint8Arrays into one.
*/
function concatBytes(...arrays) {
let sum = 0;
for (let i = 0; i < arrays.length; i++) {
const a = arrays[i];
abytes(a);
sum += a.length;
}
const res = new Uint8Array(sum);
for (let i = 0, pad = 0; i < arrays.length; i++) {
const a = arrays[i];
res.set(a, pad);
pad += a.length;
}
return res;
}
function checkOpts(defaults, opts) {
if (opts == null || typeof opts !== 'object')
throw new Error('options must be defined');
const merged = Object.assign(defaults, opts);
return merged;
}
/** Compares 2 uint8array-s in kinda constant time. */
function equalBytes(a, b) {
if (a.length !== b.length)
return false;
let diff = 0;
for (let i = 0; i < a.length; i++)
diff |= a[i] ^ b[i];
return diff === 0;
}
// TODO: remove
/** For runtime check if class implements interface. */
class Hash {
}
exports.Hash = Hash;
/**
* Wraps a cipher: validates args, ensures encrypt() can only be called once.
* @__NO_SIDE_EFFECTS__
*/
const wrapCipher = (params, constructor) => {
function wrappedCipher(key, ...args) {
// Validate key
abytes(key);
// Big-Endian hardware is rare. Just in case someone still decides to run ciphers:
if (!exports.isLE)
throw new Error('Non little-endian hardware is not yet supported');
// Validate nonce if nonceLength is present
if (params.nonceLength !== undefined) {
const nonce = args[0];
if (!nonce)
throw new Error('nonce / iv required');
if (params.varSizeNonce)
abytes(nonce);
else
abytes(nonce, params.nonceLength);
}
// Validate AAD if tagLength present
const tagl = params.tagLength;
if (tagl && args[1] !== undefined) {
abytes(args[1]);
}
const cipher = constructor(key, ...args);
const checkOutput = (fnLength, output) => {
if (output !== undefined) {
if (fnLength !== 2)
throw new Error('cipher output not supported');
abytes(output);
}
};
// Create wrapped cipher with validation and single-use encryption
let called = false;
const wrCipher = {
encrypt(data, output) {
if (called)
throw new Error('cannot encrypt() twice with same key + nonce');
called = true;
abytes(data);
checkOutput(cipher.encrypt.length, output);
return cipher.encrypt(data, output);
},
decrypt(data, output) {
abytes(data);
if (tagl && data.length < tagl)
throw new Error('invalid ciphertext length: smaller than tagLength=' + tagl);
checkOutput(cipher.decrypt.length, output);
return cipher.decrypt(data, output);
},
};
return wrCipher;
}
Object.assign(wrappedCipher, params);
return wrappedCipher;
};
exports.wrapCipher = wrapCipher;
/**
* By default, returns u8a of length.
* When out is available, it checks it for validity and uses it.
*/
function getOutput(expectedLength, out, onlyAligned = true) {
if (out === undefined)
return new Uint8Array(expectedLength);
if (out.length !== expectedLength)
throw new Error('invalid output length, expected ' + expectedLength + ', got: ' + out.length);
if (onlyAligned && !isAligned32(out))
throw new Error('invalid output, must be aligned');
return out;
}
/** Polyfill for Safari 14. */
function setBigUint64(view, byteOffset, value, isLE) {
if (typeof view.setBigUint64 === 'function')
return view.setBigUint64(byteOffset, value, isLE);
const _32n = BigInt(32);
const _u32_max = BigInt(0xffffffff);
const wh = Number((value >> _32n) & _u32_max);
const wl = Number(value & _u32_max);
const h = isLE ? 4 : 0;
const l = isLE ? 0 : 4;
view.setUint32(byteOffset + h, wh, isLE);
view.setUint32(byteOffset + l, wl, isLE);
}
function u64Lengths(dataLength, aadLength, isLE) {
abool(isLE);
const num = new Uint8Array(16);
const view = createView(num);
setBigUint64(view, 0, BigInt(aadLength), isLE);
setBigUint64(view, 8, BigInt(dataLength), isLE);
return num;
}
// Is byte array aligned to 4 byte offset (u32)?
function isAligned32(bytes) {
return bytes.byteOffset % 4 === 0;
}
// copy bytes to new u8a (aligned). Because Buffer.slice is broken.
function copyBytes(bytes) {
return Uint8Array.from(bytes);
}
},{}],5:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.crypto = void 0;
exports.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
},{}],6:[function(require,module,exports){
"use strict";
/**
* Utilities for hex, bytes, CSPRNG.
* @module
*/
/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
Object.defineProperty(exports, "__esModule", { value: true });
exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.Hash = exports.nextTick = exports.swap32IfBE = exports.byteSwapIfBE = exports.swap8IfBE = exports.isLE = void 0;
exports.isBytes = isBytes;
exports.anumber = anumber;
exports.abytes = abytes;
exports.ahash = ahash;
exports.aexists = aexists;
exports.aoutput = aoutput;
exports.u8 = u8;
exports.u32 = u32;
exports.clean = clean;
exports.createView = createView;
exports.rotr = rotr;
exports.rotl = rotl;
exports.byteSwap = byteSwap;
exports.byteSwap32 = byteSwap32;
exports.bytesToHex = bytesToHex;
exports.hexToBytes = hexToBytes;
exports.asyncLoop = asyncLoop;
exports.utf8ToBytes = utf8ToBytes;
exports.bytesToUtf8 = bytesToUtf8;
exports.toBytes = toBytes;
exports.kdfInputToBytes = kdfInputToBytes;
exports.concatBytes = concatBytes;
exports.checkOpts = checkOpts;
exports.createHasher = createHasher;
exports.createOptHasher = createOptHasher;
exports.createXOFer = createXOFer;
exports.randomBytes = randomBytes;
// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
// node.js versions earlier than v19 don't declare it in global scope.
// For node.js, package.json#exports field mapping rewrites import
// from `crypto` to `cryptoNode`, which imports native module.
// Makes the utils un-importable in browsers without a bundler.
// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
const crypto_1 = require("@noble/hashes/crypto");
/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
function isBytes(a) {
return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
}
/** Asserts something is positive integer. */
function anumber(n) {
if (!Number.isSafeInteger(n) || n < 0)
throw new Error('positive integer expected, got ' + n);
}
/** Asserts something is Uint8Array. */
function abytes(b, ...lengths) {
if (!isBytes(b))
throw new Error('Uint8Array expected');
if (lengths.length > 0 && !lengths.includes(b.length))
throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
}
/** Asserts something is hash */
function ahash(h) {
if (typeof h !== 'function' || typeof h.create !== 'function')
throw new Error('Hash should be wrapped by utils.createHasher');
anumber(h.outputLen);
anumber(h.blockLen);
}
/** Asserts a hash instance has not been destroyed / finished */
function aexists(instance, checkFinished = true) {
if (instance.destroyed)
throw new Error('Hash instance has been destroyed');
if (checkFinished && instance.finished)
throw new Error('Hash#digest() has already been called');
}
/** Asserts output is properly-sized byte array */
function aoutput(out, instance) {
abytes(out);
const min = instance.outputLen;
if (out.length < min) {
throw new Error('digestInto() expects output buffer of length at least ' + min);
}
}
/** Cast u8 / u16 / u32 to u8. */
function u8(arr) {
return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
}
/** Cast u8 / u16 / u32 to u32. */
function u32(arr) {
return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
}
/** Zeroize a byte array. Warning: JS provides no guarantees. */
function clean(...arrays) {
for (let i = 0; i < arrays.length; i++) {
arrays[i].fill(0);
}
}
/** Create DataView of an array for easy byte-level manipulation. */
function createView(arr) {
return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
}
/** The rotate right (circular right shift) operation for uint32 */
function rotr(word, shift) {
return (word << (32 - shift)) | (word >>> shift);
}
/** The rotate left (circular left shift) operation for uint32 */
function rotl(word, shift) {
return (word << shift) | ((word >>> (32 - shift)) >>> 0);
}
/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
exports.isLE = (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
/** The byte swap operation for uint32 */
function byteSwap(word) {
return (((word << 24) & 0xff000000) |
((word << 8) & 0xff0000) |
((word >>> 8) & 0xff00) |
((word >>> 24) & 0xff));
}
/** Conditionally byte swap if on a big-endian platform */
exports.swap8IfBE = exports.isLE
? (n) => n
: (n) => byteSwap(n);
/** @deprecated */
exports.byteSwapIfBE = exports.swap8IfBE;
/** In place byte swap for Uint32Array */
function byteSwap32(arr) {
for (let i = 0; i < arr.length; i++) {
arr[i] = byteSwap(arr[i]);
}
return arr;
}
exports.swap32IfBE = exports.isLE
? (u) => u
: byteSwap32;
// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
const hasHexBuiltin = /* @__PURE__ */ (() =>
// @ts-ignore
typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function')();
// Array where index 0xf0 (240) is mapped to string 'f0'
const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
/**
* Convert byte array to hex string. Uses built-in function, when available.
* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
*/
function bytesToHex(bytes) {
abytes(bytes);
// @ts-ignore
if (hasHexBuiltin)
return bytes.toHex();
// pre-caching improves the speed 6x
let hex = '';
for (let i = 0; i < bytes.length; i++) {
hex += hexes[bytes[i]];
}
return hex;
}
// We use optimized technique to convert hex string to byte array
const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
function asciiToBase16(ch) {
if (ch >= asciis._0 && ch <= asciis._9)
return ch - asciis._0; // '2' => 50-48
if (ch >= asciis.A && ch <= asciis.F)
return ch - (asciis.A - 10); // 'B' => 66-(65-10)
if (ch >= asciis.a && ch <= asciis.f)
return ch - (asciis.a - 10); // 'b' => 98-(97-10)
return;
}
/**
* Convert hex string to byte array. Uses built-in function, when available.
* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
*/
function hexToBytes(hex) {
if (typeof hex !== 'string')
throw new Error('hex string expected, got ' + typeof hex);
// @ts-ignore
if (hasHexBuiltin)
return Uint8Array.fromHex(hex);
const hl = hex.length;
const al = hl / 2;
if (hl % 2)
throw new Error('hex string expected, got unpadded hex of length ' + hl);
const array = new Uint8Array(al);
for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
const n1 = asciiToBase16(hex.charCodeAt(hi));
const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
if (n1 === undefined || n2 === undefined) {
const char = hex[hi] + hex[hi + 1];
throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
}
array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
}
return array;
}
/**
* There is no setImmediate in browser and setTimeout is slow.
* Call of async fn will return Promise, which will be fullfiled only on
* next scheduler queue processing step and this is exactly what we need.
*/
const nextTick = async () => { };
exports.nextTick = nextTick;
/** Returns control to thread each 'tick' ms to avoid blocking. */
async function asyncLoop(iters, tick, cb) {
let ts = Date.now();
for (let i = 0; i < iters; i++) {
cb(i);
// Date.now() is not monotonic, so in case if clock goes backwards we return return control too
const diff = Date.now() - ts;
if (diff >= 0 && diff < tick)
continue;
await (0, exports.nextTick)();
ts += diff;
}
}
/**
* Converts string to bytes using UTF8 encoding.
* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
*/
function utf8ToBytes(str) {
if (typeof str !== 'string')
throw new Error('string expected');
return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
}
/**
* Converts bytes to string using UTF8 encoding.
* @example bytesToUtf8(Uint8Array.from([97, 98, 99])) // 'abc'
*/
function bytesToUtf8(bytes) {
return new TextDecoder().decode(bytes);
}
/**
* Normalizes (non-hex) string or Uint8Array to Uint8Array.
* Warning: when Uint8Array is passed, it would NOT get copied.
* Keep in mind for future mutable operations.
*/
function toBytes(data) {
if (typeof data === 'string')
data = utf8ToBytes(data);
abytes(data);
return data;
}
/**
* Helper for KDFs: consumes uint8array or string.
* When string is passed, does utf8 decoding, using TextDecoder.
*/
function kdfInputToBytes(data) {
if (typeof data === 'string')
data = utf8ToBytes(data);
abytes(data);
return data;
}
/** Copies several Uint8Arrays into one. */
function concatBytes(...arrays) {
let sum = 0;
for (let i = 0; i < arrays.length; i++) {
const a = arrays[i];
abytes(a);
sum += a.length;
}
const res = new Uint8Array(sum);
for (let i = 0, pad = 0; i < arrays.length; i++) {
const a = arrays[i];
res.set(a, pad);
pad += a.length;
}
return res;
}
function checkOpts(defaults, opts) {
if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')
throw new Error('options should be object or undefined');
const merged = Object.assign(defaults, opts);
return merged;
}
/** For runtime check if class implements interface */
class Hash {
}
exports.Hash = Hash;
/** Wraps hash function, creating an interface on top of it */
function createHasher(hashCons) {
const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
const tmp = hashCons();
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = () => hashCons();
return hashC;
}
function createOptHasher(hashCons) {
const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
const tmp = hashCons({});
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = (opts) => hashCons(opts);
return hashC;
}
function createXOFer(hashCons) {
const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
const tmp = hashCons({});
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = (opts) => hashCons(opts);
return hashC;
}
exports.wrapConstructor = createHasher;
exports.wrapConstructorWithOpts = createOptHasher;
exports.wrapXOFConstructorWithOpts = createXOFer;
/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
function randomBytes(bytesLength = 32) {
if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {
return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
}
// Legacy Node.js compatibility
if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === 'function') {
return Uint8Array.from(crypto_1.crypto.randomBytes(bytesLength));
}
throw new Error('crypto.getRandomValues must be defined');
}
},{"@noble/hashes/crypto":5}],7:[function(require,module,exports){
"use strict";
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
} else obj[key] = value;
return obj;
}
exports._ = _define_property;
},{}],8:[function(require,module,exports){
"use strict";
exports._ = require("tslib").__decorate;
},{"tslib":34}],9:[function(require,module,exports){
'use strict'
exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray
var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
lookup[i] = code[i]
revLookup[code.charCodeAt(i)] = i
}
// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63
function getLens (b64) {
var len = b64.length
if (len % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// Trim off extra bytes after placeholder bytes are found
// See: https://github.com/beatgammit/base64-js/issues/42
var validLen = b64.indexOf('=')
if (validLen === -1) validLen = len
var placeHoldersLen = validLen === len
? 0
: 4 - (validLen % 4)
return [validLen, placeHoldersLen]
}
// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function _byteLength (b64, validLen, placeHoldersLen) {
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
function toByteArray (b64) {
var tmp
var lens = getLens(b64)
var validLen = lens[0]
var placeHoldersLen = lens[1]
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
var curByte = 0
// if there are placeholders, only get up to the last complete 4 chars
var len = placeHoldersLen > 0
? validLen - 4
: validLen
var i
for (i = 0; i < len; i += 4) {
tmp =
(revLookup[b64.charCodeAt(i)] << 18) |
(revLookup[b64.charCodeAt(i + 1)] << 12) |
(revLookup[b64.charCodeAt(i + 2)] << 6) |
revLookup[b64.charCodeAt(i + 3)]
arr[curByte++] = (tmp >> 16) & 0xFF
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 2) {
tmp =
(revLookup[b64.charCodeAt(i)] << 2) |
(revLookup[b64.charCodeAt(i + 1)] >> 4)
arr[curByte++] = tmp & 0xFF
}
if (placeHoldersLen === 1) {
tmp =
(revLookup[b64.charCodeAt(i)] << 10) |
(revLookup[b64.charCodeAt(i + 1)] << 4) |
(revLookup[b64.charCodeAt(i + 2)] >> 2)
arr[curByte++] = (tmp >> 8) & 0xFF
arr[curByte++] = tmp & 0xFF
}
return arr
}
function tripletToBase64 (num) {
return lookup[num >> 18 & 0x3F] +
lookup[num >> 12 & 0x3F] +
lookup[num >> 6 & 0x3F] +
lookup[num & 0x3F]
}
function encodeChunk (uint8, start, end) {
var tmp
var output = []
for (var i = start; i < end; i += 3) {
tmp =
((uint8[i] << 16) & 0xFF0000) +
((uint8[i + 1] << 8) & 0xFF00) +
(uint8[i + 2] & 0xFF)
output.push(tripletToBase64(tmp))
}
return output.join('')
}
function fromByteArray (uint8) {
var tmp
var len = uint8.length
var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
var parts = []
var maxChunkLength = 16383 // must be multiple of 3
// go through the array every three bytes, we'll deal with trailing stuff later
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
}
// pad the end with zeros, but make sure to not forget the extra bytes
if (extraBytes === 1) {
tmp = uint8[len - 1]
parts.push(
lookup[tmp >> 2] +
lookup[(tmp << 4) & 0x3F] +
'=='
)
} else if (extraBytes === 2) {
tmp = (uint8[len - 2] << 8) + uint8[len - 1]
parts.push(
lookup[tmp >> 10] +
lookup[(tmp >> 4) & 0x3F] +
lookup[(tmp << 2) & 0x3F] +
'='
)
}
return parts.join('')
}
},{}],10:[function(require,module,exports){
/* Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Bit reading helpers
*/
var BROTLI_READ_SIZE = 4096;
var BROTLI_IBUF_SIZE = (2 * BROTLI_READ_SIZE + 32);
var BROTLI_IBUF_MASK = (2 * BROTLI_READ_SIZE - 1);
var kBitMask = new Uint32Array([
0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767,
65535, 131071, 262143, 524287, 1048575, 2097151, 4194303, 8388607, 16777215
]);
/* Input byte buffer, consist of a ringbuffer and a "slack" region where */
/* bytes from the start of the ringbuffer are copied. */
function BrotliBitReader(input) {
this.buf_ = new Uint8Array(BROTLI_IBUF_SIZE);
this.input_ = input; /* input callback */
this.reset();
}
BrotliBitReader.READ_SIZE = BROTLI_READ_SIZE;
BrotliBitReader.IBUF_MASK = BROTLI_IBUF_MASK;
BrotliBitReader.prototype.reset = function() {
this.buf_ptr_ = 0; /* next input will write here */
this.val_ = 0; /* pre-fetched bits */
this.pos_ = 0; /* byte position in stream */
this.bit_pos_ = 0; /* current bit-reading position in val_ */
this.bit_end_pos_ = 0; /* bit-reading end position from LSB of val_ */
this.eos_ = 0; /* input stream is finished */
this.readMoreInput();
for (var i = 0; i < 4; i++) {
this.val_ |= this.buf_[this.pos_] << (8 * i);
++this.pos_;
}
return this.bit_end_pos_ > 0;
};
/* Fills up the input ringbuffer by calling the input callback.
Does nothing if there are at least 32 bytes present after current position.
Returns 0 if either:
- the input callback returned an error, or
- there is no more input and the position is past the end of the stream.
After encountering the end of the input stream, 32 additional zero bytes are
copied to the ringbuffer, therefore it is safe to call this function after
every 32 bytes of input is read.
*/
BrotliBitReader.prototype.readMoreInput = function() {
if (this.bit_end_pos_ > 256) {
return;
} else if (this.eos_) {
if (this.bit_pos_ > this.bit_end_pos_)
throw new Error('Unexpected end of input ' + this.bit_pos_ + ' ' + this.bit_end_pos_);
} else {
var dst = this.buf_ptr_;
var bytes_read = this.input_.read(this.buf_, dst, BROTLI_READ_SIZE);
if (bytes_read < 0) {
throw new Error('Unexpected end of input');
}
if (bytes_read < BROTLI_READ_SIZE) {
this.eos_ = 1;
/* Store 32 bytes of zero after the stream end. */
for (var p = 0; p < 32; p++)
this.buf_[dst + bytes_read + p] = 0;
}
if (dst === 0) {
/* Copy the head of the ringbuffer to the slack region. */
for (var p = 0; p < 32; p++)
this.buf_[(BROTLI_READ_SIZE << 1) + p] = this.buf_[p];
this.buf_ptr_ = BROTLI_READ_SIZE;
} else {
this.buf_ptr_ = 0;
}
this.bit_end_pos_ += bytes_read << 3;
}
};
/* Guarantees that there are at least 24 bits in the buffer. */
BrotliBitReader.prototype.fillBitWindow = function() {
while (this.bit_pos_ >= 8) {
this.val_ >>>= 8;
this.val_ |= this.buf_[this.pos_ & BROTLI_IBUF_MASK] << 24;
++this.pos_;
this.bit_pos_ = this.bit_pos_ - 8 >>> 0;
this.bit_end_pos_ = this.bit_end_pos_ - 8 >>> 0;
}
};
/* Reads the specified number of bits from Read Buffer. */
BrotliBitReader.prototype.readBits = function(n_bits) {
if (32 - this.bit_pos_ < n_bits) {
this.fillBitWindow();
}
var val = ((this.val_ >>> this.bit_pos_) & kBitMask[n_bits]);
this.bit_pos_ += n_bits;
return val;
};
module.exports = BrotliBitReader;
},{}],11:[function(require,module,exports){
/* Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Lookup table to map the previous two bytes to a context id.
There are four different context modeling modes defined here:
CONTEXT_LSB6: context id is the least significant 6 bits of the last byte,
CONTEXT_MSB6: context id is the most significant 6 bits of the last byte,
CONTEXT_UTF8: second-order context model tuned for UTF8-encoded text,
CONTEXT_SIGNED: second-order context model tuned for signed integers.
The context id for the UTF8 context model is calculated as follows. If p1
and p2 are the previous two bytes, we calcualte the context as
context = kContextLookup[p1] | kContextLookup[p2 + 256].
If the previous two bytes are ASCII characters (i.e. < 128), this will be
equivalent to
context = 4 * context1(p1) + context2(p2),
where context1 is based on the previous byte in the following way:
0 : non-ASCII control
1 : \t, \n, \r
2 : space
3 : other punctuation
4 : " '
5 : %
6 : ( < [ {
7 : ) > ] }
8 : , ; :
9 : .
10 : =
11 : number
12 : upper-case vowel
13 : upper-case consonant
14 : lower-case vowel
15 : lower-case consonant
and context2 is based on the second last byte:
0 : control, space
1 : punctuation
2 : upper-case letter, number
3 : lower-case letter
If the last byte is ASCII, and the second last byte is not (in a valid UTF8
stream it will be a continuation byte, value between 128 and 191), the
context is the same as if the second last byte was an ASCII control or space.
If the last byte is a UTF8 lead byte (value >= 192), then the next byte will
be a continuation byte and the context id is 2 or 3 depending on the LSB of
the last byte and to a lesser extent on the second last byte if it is ASCII.
If the last byte is a UTF8 continuation byte, the second last byte can be:
- continuation byte: the next byte is probably ASCII or lead byte (assuming
4-byte UTF8 characters are rare) and the context id is 0 or 1.
- lead byte (192 - 207): next byte is ASCII or lead byte, context is 0 or 1
- lead byte (208 - 255): next byte is continuation byte, context is 2 or 3
The possible value combinations of the previous two bytes, the range of
context ids and the type of the next byte is summarized in the table below:
|--------\-----------------------------------------------------------------|
| \ Last byte |
| Second \---------------------------------------------------------------|
| last byte \ ASCII | cont. byte | lead byte |
| \ (0-127) | (128-191) | (192-) |
|=============|===================|=====================|==================|
| ASCII | next: ASCII/lead | not valid | next: cont. |
| (0-127) | context: 4 - 63 | | context: 2 - 3 |
|-------------|-------------------|---------------------|------------------|
| cont. byte | next: ASCII/lead | next: ASCII/lead | next: cont. |
| (128-191) | context: 4 - 63 | context: 0 - 1 | context: 2 - 3 |
|-------------|-------------------|---------------------|------------------|
| lead byte | not valid | next: ASCII/lead | not valid |
| (192-207) | | context: 0 - 1 | |
|-------------|-------------------|---------------------|------------------|
| lead byte | not valid | next: cont. | not valid |
| (208-) | | context: 2 - 3 | |
|-------------|-------------------|---------------------|------------------|
The context id for the signed context mode is calculated as:
context = (kContextLookup[512 + p1] << 3) | kContextLookup[512 + p2].
For any context modeling modes, the context ids can be calculated by |-ing
together two lookups from one table using context model dependent offsets:
context = kContextLookup[offset1 + p1] | kContextLookup[offset2 + p2].
where offset1 and offset2 are dependent on the context mode.
*/
var CONTEXT_LSB6 = 0;
var CONTEXT_MSB6 = 1;
var CONTEXT_UTF8 = 2;
var CONTEXT_SIGNED = 3;
/* Common context lookup table for all context modes. */
exports.lookup = new Uint8Array([
/* CONTEXT_UTF8, last byte. */
/* ASCII range. */
0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 0, 0, 4, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
8, 12, 16, 12, 12, 20, 12, 16, 24, 28, 12, 12, 32, 12, 36, 12,
44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 32, 32, 24, 40, 28, 12,
12, 48, 52, 52, 52, 48, 52, 52, 52, 48, 52, 52, 52, 52, 52, 48,
52, 52, 52, 52, 52, 48, 52, 52, 52, 52, 52, 24, 12, 28, 12, 12,
12, 56, 60, 60, 60, 56, 60, 60, 60, 56, 60, 60, 60, 60, 60, 56,
60, 60, 60, 60, 60, 56, 60, 60, 60, 60, 60, 24, 12, 28, 12, 0,
/* UTF8 continuation byte range. */
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
/* UTF8 lead byte range. */
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3,
/* CONTEXT_UTF8 second last byte. */
/* ASCII range. */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1,
1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, 0,
/* UTF8 continuation byte range. */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* UTF8 lead byte range. */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
/* CONTEXT_SIGNED, second last byte. */
0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7,
/* CONTEXT_SIGNED, last byte, same as the above values shifted by 3 bits. */
0, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 56,
/* CONTEXT_LSB6, last byte. */
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
/* CONTEXT_MSB6, last byte. */
0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7,
8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11,
12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15,
16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19,
20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23,
24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 27,
28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 30, 31, 31, 31, 31,
32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35,
36, 36, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 39, 39, 39,
40, 40, 40, 40, 41, 41, 41, 41, 42, 42, 42, 42, 43, 43, 43, 43,
44, 44, 44, 44, 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47,
48, 48, 48, 48, 49, 49, 49, 49, 50, 50, 50, 50, 51, 51, 51, 51,
52, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 55, 55,
56, 56, 56, 56, 57, 57, 57, 57, 58, 58, 58, 58, 59, 59, 59, 59,
60, 60, 60, 60, 61, 61, 61, 61, 62, 62, 62, 62, 63, 63, 63, 63,
/* CONTEXT_{M,L}SB6, second last byte, */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
]);
exports.lookupOffsets = new Uint16Array([
/* CONTEXT_LSB6 */
1024, 1536,
/* CONTEXT_MSB6 */
1280, 1536,
/* CONTEXT_UTF8 */
0, 256,
/* CONTEXT_SIGNED */
768, 512,
]);
},{}],12:[function(require,module,exports){
/* Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
var BrotliInput = require('./streams').BrotliInput;
var BrotliOutput = require('./streams').BrotliOutput;
var BrotliBitReader = require('./bit_reader');
var BrotliDictionary = require('./dictionary');
var HuffmanCode = require('./huffman').HuffmanCode;
var BrotliBuildHuffmanTable = require('./huffman').BrotliBuildHuffmanTable;
var Context = require('./context');
var Prefix = require('./prefix');
var Transform = require('./transform');
var kDefaultCodeLength = 8;
var kCodeLengthRepeatCode = 16;
var kNumLiteralCodes = 256;
var kNumInsertAndCopyCodes = 704;
var kNumBlockLengthCodes = 26;
var kLiteralContextBits = 6;
var kDistanceContextBits = 2;
var HUFFMAN_TABLE_BITS = 8;
var HUFFMAN_TABLE_MASK = 0xff;
/* Maximum possible Huffman table size for an alphabet size of 704, max code
* length 15 and root table bits 8. */
var HUFFMAN_MAX_TABLE_SIZE = 1080;
var CODE_LENGTH_CODES = 18;
var kCodeLengthCodeOrder = new Uint8Array([
1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15,
]);
var NUM_DISTANCE_SHORT_CODES = 16;
var kDistanceShortCodeIndexOffset = new Uint8Array([
3, 2, 1, 0, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2
]);
var kDistanceShortCodeValueOffset = new Int8Array([
0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3
]);
var kMaxHuffmanTableSize = new Uint16Array([
256, 402, 436, 468, 500, 534, 566, 598, 630, 662, 694, 726, 758, 790, 822,
854, 886, 920, 952, 984, 1016, 1048, 1080
]);
function DecodeWindowBits(br) {
var n;
if (br.readBits(1) === 0) {
return 16;
}
n = br.readBits(3);
if (n > 0) {
return 17 + n;
}
n = br.readBits(3);
if (n > 0) {
return 8 + n;
}
return 17;
}
/* Decodes a number in the range [0..255], by reading 1 - 11 bits. */
function DecodeVarLenUint8(br) {
if (br.readBits(1)) {
var nbits = br.readBits(3);
if (nbits === 0) {
return 1;
} else {
return br.readBits(nbits) + (1 << nbits);
}
}
return 0;
}
function MetaBlockLength() {
this.meta_block_length = 0;
this.input_end = 0;
this.is_uncompressed = 0;
this.is_metadata = false;
}
function DecodeMetaBlockLength(br) {
var out = new MetaBlockLength;
var size_nibbles;
var size_bytes;
var i;
out.input_end = br.readBits(1);
if (out.input_end && br.readBits(1)) {
return out;
}
size_nibbles = br.readBits(2) + 4;
if (size_nibbles === 7) {
out.is_metadata = true;
if (br.readBits(1) !== 0)
throw new Error('Invalid reserved bit');
size_bytes = br.readBits(2);
if (size_bytes === 0)
return out;
for (i = 0; i < size_bytes; i++) {
var next_byte = br.readBits(8);
if (i + 1 === size_bytes && size_bytes > 1 && next_byte === 0)
throw new Error('Invalid size byte');
out.meta_block_length |= next_byte << (i * 8);
}
} else {
for (i = 0; i < size_nibbles; ++i) {
var next_nibble = br.readBits(4);
if (i + 1 === size_nibbles && size_nibbles > 4 && next_nibble === 0)
throw new Error('Invalid size nibble');
out.meta_block_length |= next_nibble << (i * 4);
}
}
++out.meta_block_length;
if (!out.input_end && !out.is_metadata) {
out.is_uncompressed = br.readBits(1);
}
return out;
}
/* Decodes the next Huffman code from bit-stream. */
function ReadSymbol(table, index, br) {
var start_index = index;
var nbits;
br.fillBitWindow();
index += (br.val_ >>> br.bit_pos_) & HUFFMAN_TABLE_MASK;
nbits = table[index].bits - HUFFMAN_TABLE_BITS;
if (nbits > 0) {
br.bit_pos_ += HUFFMAN_TABLE_BITS;
index += table[index].value;
index += (br.val_ >>> br.bit_pos_) & ((1 << nbits) - 1);
}
br.bit_pos_ += table[index].bits;
return table[index].value;
}
function ReadHuffmanCodeLengths(code_length_code_lengths, num_symbols, code_lengths, br) {
var symbol = 0;
var prev_code_len = kDefaultCodeLength;
var repeat = 0;
var repeat_code_len = 0;
var space = 32768;
var table = [];
for (var i = 0; i < 32; i++)
table.push(new HuffmanCode(0, 0));
BrotliBuildHuffmanTable(table, 0, 5, code_length_code_lengths, CODE_LENGTH_CODES);
while (symbol < num_symbols && space > 0) {
var p = 0;
var code_len;
br.readMoreInput();
br.fillBitWindow();
p += (br.val_ >>> br.bit_pos_) & 31;
br.bit_pos_ += table[p].bits;
code_len = table[p].value & 0xff;
if (code_len < kCodeLengthRepeatCode) {
repeat = 0;
code_lengths[symbol++] = code_len;
if (code_len !== 0) {
prev_code_len = code_len;
space -= 32768 >> code_len;
}
} else {
var extra_bits = code_len - 14;
var old_repeat;
var repeat_delta;
var new_len = 0;
if (code_len === kCodeLengthRepeatCode) {
new_len = prev_code_len;
}
if (repeat_code_len !== new_len) {
repeat = 0;
repeat_code_len = new_len;
}
old_repeat = repeat;
if (repeat > 0) {
repeat -= 2;
repeat <<= extra_bits;
}
repeat += br.readBits(extra_bits) + 3;
repeat_delta = repeat - old_repeat;
if (symbol + repeat_delta > num_symbols) {
throw new Error('[ReadHuffmanCodeLengths] symbol + repeat_delta > num_symbols');
}
for (var x = 0; x < repeat_delta; x++)
code_lengths[symbol + x] = repeat_code_len;
symbol += repeat_delta;
if (repeat_code_len !== 0) {
space -= repeat_delta << (15 - repeat_code_len);
}
}
}
if (space !== 0) {
throw new Error("[ReadHuffmanCodeLengths] space = " + space);
}
for (; symbol < num_symbols; symbol++)
code_lengths[symbol] = 0;
}
function ReadHuffmanCode(alphabet_size, tables, table, br) {
var table_size = 0;
var simple_code_or_skip;
var code_lengths = new Uint8Array(alphabet_size);
br.readMoreInput();
/* simple_code_or_skip is used as follows:
1 for simple code;
0 for no skipping, 2 skips 2 code lengths, 3 skips 3 code lengths */
simple_code_or_skip = br.readBits(2);
if (simple_code_or_skip === 1) {
/* Read symbols, codes & code lengths directly. */
var i;
var max_bits_counter = alphabet_size - 1;
var max_bits = 0;
var symbols = new Int32Array(4);
var num_symbols = br.readBits(2) + 1;
while (max_bits_counter) {
max_bits_counter >>= 1;
++max_bits;
}
for (i = 0; i < num_symbols; ++i) {
symbols[i] = br.readBits(max_bits) % alphabet_size;
code_lengths[symbols[i]] = 2;
}
code_lengths[symbols[0]] = 1;
switch (num_symbols) {
case 1:
break;
case 3:
if ((symbols[0] === symbols[1]) ||
(symbols[0] === symbols[2]) ||
(symbols[1] === symbols[2])) {
throw new Error('[ReadHuffmanCode] invalid symbols');
}
break;
case 2:
if (symbols[0] === symbols[1]) {
throw new Error('[ReadHuffmanCode] invalid symbols');
}
code_lengths[symbols[1]] = 1;
break;
case 4:
if ((symbols[0] === symbols[1]) ||
(symbols[0] === symbols[2]) ||
(symbols[0] === symbols[3]) ||
(symbols[1] === symbols[2]) ||
(symbols[1] === symbols[3]) ||
(symbols[2] === symbols[3])) {
throw new Error('[ReadHuffmanCode] invalid symbols');
}
if (br.readBits(1)) {
code_lengths[symbols[2]] = 3;
code_lengths[symbols[3]] = 3;
} else {
code_lengths[symbols[0]] = 2;
}
break;
}
} else { /* Decode Huffman-coded code lengths. */
var i;
var code_length_code_lengths = new Uint8Array(CODE_LENGTH_CODES);
var space = 32;
var num_codes = 0;
/* Static Huffman code for the code length code lengths */
var huff = [
new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2),
new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(4, 1),
new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(3, 2),
new HuffmanCode(2, 0), new HuffmanCode(2, 4), new HuffmanCode(2, 3), new HuffmanCode(4, 5)
];
for (i = simple_code_or_skip; i < CODE_LENGTH_CODES && space > 0; ++i) {
var code_len_idx = kCodeLengthCodeOrder[i];
var p = 0;
var v;
br.fillBitWindow();
p += (br.val_ >>> br.bit_pos_) & 15;
br.bit_pos_ += huff[p].bits;
v = huff[p].value;
code_length_code_lengths[code_len_idx] = v;
if (v !== 0) {
space -= (32 >> v);
++num_codes;
}
}
if (!(num_codes === 1 || space === 0))
throw new Error('[ReadHuffmanCode] invalid num_codes or space');
ReadHuffmanCodeLengths(code_length_code_lengths, alphabet_size, code_lengths, br);
}
table_size = BrotliBuildHuffmanTable(tables, table, HUFFMAN_TABLE_BITS, code_lengths, alphabet_size);
if (table_size === 0) {
throw new Error("[ReadHuffmanCode] BuildHuffmanTable failed: ");
}
return table_size;
}
function ReadBlockLength(table, index, br) {
var code;
var nbits;
code = ReadSymbol(table, index, br);
nbits = Prefix.kBlockLengthPrefixCode[code].nbits;
return Prefix.kBlockLengthPrefixCode[code].offset + br.readBits(nbits);
}
function TranslateShortCodes(code, ringbuffer, index) {
var val;
if (code < NUM_DISTANCE_SHORT_CODES) {
index += kDistanceShortCodeIndexOffset[code];
index &= 3;
val = ringbuffer[index] + kDistanceShortCodeValueOffset[code];
} else {
val = code - NUM_DISTANCE_SHORT_CODES + 1;
}
return val;
}
function MoveToFront(v, index) {
var value = v[index];
var i = index;
for (; i; --i) v[i] = v[i - 1];
v[0] = value;
}
function InverseMoveToFrontTransform(v, v_len) {
var mtf = new Uint8Array(256);
var i;
for (i = 0; i < 256; ++i) {
mtf[i] = i;
}
for (i = 0; i < v_len; ++i) {
var index = v[i];
v[i] = mtf[index];
if (index) MoveToFront(mtf, index);
}
}
/* Contains a collection of huffman trees with the same alphabet size. */
function HuffmanTreeGroup(alphabet_size, num_htrees) {
this.alphabet_size = alphabet_size;
this.num_htrees = num_htrees;
this.codes = new Array(num_htrees + num_htrees * kMaxHuffmanTableSize[(alphabet_size + 31) >>> 5]);
this.htrees = new Uint32Array(num_htrees);
}
HuffmanTreeGroup.prototype.decode = function(br) {
var i;
var table_size;
var next = 0;
for (i = 0; i < this.num_htrees; ++i) {
this.htrees[i] = next;
table_size = ReadHuffmanCode(this.alphabet_size, this.codes, next, br);
next += table_size;
}
};
function DecodeContextMap(context_map_size, br) {
var out = { num_htrees: null, context_map: null };
var use_rle_for_zeros;
var max_run_length_prefix = 0;
var table;
var i;
br.readMoreInput();
var num_htrees = out.num_htrees = DecodeVarLenUint8(br) + 1;
var context_map = out.context_map = new Uint8Array(context_map_size);
if (num_htrees <= 1) {
return out;
}
use_rle_for_zeros = br.readBits(1);
if (use_rle_for_zeros) {
max_run_length_prefix = br.readBits(4) + 1;
}
table = [];
for (i = 0; i < HUFFMAN_MAX_TABLE_SIZE; i++) {
table[i] = new HuffmanCode(0, 0);
}
ReadHuffmanCode(num_htrees + max_run_length_prefix, table, 0, br);
for (i = 0; i < context_map_size;) {
var code;
br.readMoreInput();
code = ReadSymbol(table, 0, br);
if (code === 0) {
context_map[i] = 0;
++i;
} else if (code <= max_run_length_prefix) {
var reps = 1 + (1 << code) + br.readBits(code);
while (--reps) {
if (i >= context_map_size) {
throw new Error("[DecodeContextMap] i >= context_map_size");
}
context_map[i] = 0;
++i;
}
} else {
context_map[i] = code - max_run_length_prefix;
++i;
}
}
if (br.readBits(1)) {
InverseMoveToFrontTransform(context_map, context_map_size);
}
return out;
}
function DecodeBlockType(max_block_type, trees, tree_type, block_types, ringbuffers, indexes, br) {
var ringbuffer = tree_type * 2;
var index = tree_type;
var type_code = ReadSymbol(trees, tree_type * HUFFMAN_MAX_TABLE_SIZE, br);
var block_type;
if (type_code === 0) {
block_type = ringbuffers[ringbuffer + (indexes[index] & 1)];
} else if (type_code === 1) {
block_type = ringbuffers[ringbuffer + ((indexes[index] - 1) & 1)] + 1;
} else {
block_type = type_code - 2;
}
if (block_type >= max_block_type) {
block_type -= max_block_type;
}
block_types[tree_type] = block_type;
ringbuffers[ringbuffer + (indexes[index] & 1)] = block_type;
++indexes[index];
}
function CopyUncompressedBlockToOutput(output, len, pos, ringbuffer, ringbuffer_mask, br) {
var rb_size = ringbuffer_mask + 1;
var rb_pos = pos & ringbuffer_mask;
var br_pos = br.pos_ & BrotliBitReader.IBUF_MASK;
var nbytes;
/* For short lengths copy byte-by-byte */
if (len < 8 || br.bit_pos_ + (len << 3) < br.bit_end_pos_) {
while (len-- > 0) {
br.readMoreInput();
ringbuffer[rb_pos++] = br.readBits(8);
if (rb_pos === rb_size) {
output.write(ringbuffer, rb_size);
rb_pos = 0;
}
}
return;
}
if (br.bit_end_pos_ < 32) {
throw new Error('[CopyUncompressedBlockToOutput] br.bit_end_pos_ < 32');
}
/* Copy remaining 0-4 bytes from br.val_ to ringbuffer. */
while (br.bit_pos_ < 32) {
ringbuffer[rb_pos] = (br.val_ >>> br.bit_pos_);
br.bit_pos_ += 8;
++rb_pos;
--len;
}
/* Copy remaining bytes from br.buf_ to ringbuffer. */
nbytes = (br.bit_end_pos_ - br.bit_pos_) >> 3;
if (br_pos + nbytes > BrotliBitReader.IBUF_MASK) {
var tail = BrotliBitReader.IBUF_MASK + 1 - br_pos;
for (var x = 0; x < tail; x++)
ringbuffer[rb_pos + x] = br.buf_[br_pos + x];
nbytes -= tail;
rb_pos += tail;
len -= tail;
br_pos = 0;
}
for (var x = 0; x < nbytes; x++)
ringbuffer[rb_pos + x] = br.buf_[br_pos + x];
rb_pos += nbytes;
len -= nbytes;
/* If we wrote past the logical end of the ringbuffer, copy the tail of the
ringbuffer to its beginning and flush the ringbuffer to the output. */
if (rb_pos >= rb_size) {
output.write(ringbuffer, rb_size);
rb_pos -= rb_size;
for (var x = 0; x < rb_pos; x++)
ringbuffer[x] = ringbuffer[rb_size + x];
}
/* If we have more to copy than the remaining size of the ringbuffer, then we
first fill the ringbuffer from the input and then flush the ringbuffer to
the output */
while (rb_pos + len >= rb_size) {
nbytes = rb_size - rb_pos;
if (br.input_.read(ringbuffer, rb_pos, nbytes) < nbytes) {
throw new Error('[CopyUncompressedBlockToOutput] not enough bytes');
}
output.write(ringbuffer, rb_size);
len -= nbytes;
rb_pos = 0;
}
/* Copy straight from the input onto the ringbuffer. The ringbuffer will be
flushed to the output at a later time. */
if (br.input_.read(ringbuffer, rb_pos, len) < len) {
throw new Error('[CopyUncompressedBlockToOutput] not enough bytes');
}
/* Restore the state of the bit reader. */
br.reset();
}
/* Advances the bit reader position to the next byte boundary and verifies
that any skipped bits are set to zero. */
function JumpToByteBoundary(br) {
var new_bit_pos = (br.bit_pos_ + 7) & ~7;
var pad_bits = br.readBits(new_bit_pos - br.bit_pos_);
return pad_bits == 0;
}
function BrotliDecompressedSize(buffer) {
var input = new BrotliInput(buffer);
var br = new BrotliBitReader(input);
DecodeWindowBits(br);
var out = DecodeMetaBlockLength(br);
return out.meta_block_length;
}
exports.BrotliDecompressedSize = BrotliDecompressedSize;
function BrotliDecompressBuffer(buffer, output_size) {
var input = new BrotliInput(buffer);
if (output_size == null) {
output_size = BrotliDecompressedSize(buffer);
}
var output_buffer = new Uint8Array(output_size);
var output = new BrotliOutput(output_buffer);
BrotliDecompress(input, output);
if (output.pos < output.buffer.length) {
output.buffer = output.buffer.subarray(0, output.pos);
}
return output.buffer;
}
exports.BrotliDecompressBuffer = BrotliDecompressBuffer;
function BrotliDecompress(input, output) {
var i;
var pos = 0;
var input_end = 0;
var window_bits = 0;
var max_backward_distance;
var max_distance = 0;
var ringbuffer_size;
var ringbuffer_mask;
var ringbuffer;
var ringbuffer_end;
/* This ring buffer holds a few past copy distances that will be used by */
/* some special distance codes. */
var dist_rb = [ 16, 15, 11, 4 ];
var dist_rb_idx = 0;
/* The previous 2 bytes used for context. */
var prev_byte1 = 0;
var prev_byte2 = 0;
var hgroup = [new HuffmanTreeGroup(0, 0), new HuffmanTreeGroup(0, 0), new HuffmanTreeGroup(0, 0)];
var block_type_trees;
var block_len_trees;
var br;
/* We need the slack region for the following reasons:
- always doing two 8-byte copies for fast backward copying
- transforms
- flushing the input ringbuffer when decoding uncompressed blocks */
var kRingBufferWriteAheadSlack = 128 + BrotliBitReader.READ_SIZE;
br = new BrotliBitReader(input);
/* Decode window size. */
window_bits = DecodeWindowBits(br);
max_backward_distance = (1 << window_bits) - 16;
ringbuffer_size = 1 << window_bits;
ringbuffer_mask = ringbuffer_size - 1;
ringbuffer = new Uint8Array(ringbuffer_size + kRingBufferWriteAheadSlack + BrotliDictionary.maxDictionaryWordLength);
ringbuffer_end = ringbuffer_size;
block_type_trees = [];
block_len_trees = [];
for (var x = 0; x < 3 * HUFFMAN_MAX_TABLE_SIZE; x++) {
block_type_trees[x] = new HuffmanCode(0, 0);
block_len_trees[x] = new HuffmanCode(0, 0);
}
while (!input_end) {
var meta_block_remaining_len = 0;
var is_uncompressed;
var block_length = [ 1 << 28, 1 << 28, 1 << 28 ];
var block_type = [ 0 ];
var num_block_types = [ 1, 1, 1 ];
var block_type_rb = [ 0, 1, 0, 1, 0, 1 ];
var block_type_rb_index = [ 0 ];
var distance_postfix_bits;
var num_direct_distance_codes;
var distance_postfix_mask;
var num_distance_codes;
var context_map = null;
var context_modes = null;
var num_literal_htrees;
var dist_context_map = null;
var num_dist_htrees;
var context_offset = 0;
var context_map_slice = null;
var literal_htree_index = 0;
var dist_context_offset = 0;
var dist_context_map_slice = null;
var dist_htree_index = 0;
var context_lookup_offset1 = 0;
var context_lookup_offset2 = 0;
var context_mode;
var htree_command;
for (i = 0; i < 3; ++i) {
hgroup[i].codes = null;
hgroup[i].htrees = null;
}
br.readMoreInput();
var _out = DecodeMetaBlockLength(br);
meta_block_remaining_len = _out.meta_block_length;
if (pos + meta_block_remaining_len > output.buffer.length) {
/* We need to grow the output buffer to fit the additional data. */
var tmp = new Uint8Array( pos + meta_block_remaining_len );
tmp.set( output.buffer );
output.buffer = tmp;
}
input_end = _out.input_end;
is_uncompressed = _out.is_uncompressed;
if (_out.is_metadata) {
JumpToByteBoundary(br);
for (; meta_block_remaining_len > 0; --meta_block_remaining_len) {
br.readMoreInput();
/* Read one byte and ignore it. */
br.readBits(8);
}
continue;
}
if (meta_block_remaining_len === 0) {
continue;
}
if (is_uncompressed) {
br.bit_pos_ = (br.bit_pos_ + 7) & ~7;
CopyUncompressedBlockToOutput(output, meta_block_remaining_len, pos,
ringbuffer, ringbuffer_mask, br);
pos += meta_block_remaining_len;
continue;
}
for (i = 0; i < 3; ++i) {
num_block_types[i] = DecodeVarLenUint8(br) + 1;
if (num_block_types[i] >= 2) {
ReadHuffmanCode(num_block_types[i] + 2, block_type_trees, i * HUFFMAN_MAX_TABLE_SIZE, br);
ReadHuffmanCode(kNumBlockLengthCodes, block_len_trees, i * HUFFMAN_MAX_TABLE_SIZE, br);
block_length[i] = ReadBlockLength(block_len_trees, i * HUFFMAN_MAX_TABLE_SIZE, br);
block_type_rb_index[i] = 1;
}
}
br.readMoreInput();
distance_postfix_bits = br.readBits(2);
num_direct_distance_codes = NUM_DISTANCE_SHORT_CODES + (br.readBits(4) << distance_postfix_bits);
distance_postfix_mask = (1 << distance_postfix_bits) - 1;
num_distance_codes = (num_direct_distance_codes + (48 << distance_postfix_bits));
context_modes = new Uint8Array(num_block_types[0]);
for (i = 0; i < num_block_types[0]; ++i) {
br.readMoreInput();
context_modes[i] = (br.readBits(2) << 1);
}
var _o1 = DecodeContextMap(num_block_types[0] << kLiteralContextBits, br);
num_literal_htrees = _o1.num_htrees;
context_map = _o1.context_map;
var _o2 = DecodeContextMap(num_block_types[2] << kDistanceContextBits, br);
num_dist_htrees = _o2.num_htrees;
dist_context_map = _o2.context_map;
hgroup[0] = new HuffmanTreeGroup(kNumLiteralCodes, num_literal_htrees);
hgroup[1] = new HuffmanTreeGroup(kNumInsertAndCopyCodes, num_block_types[1]);
hgroup[2] = new HuffmanTreeGroup(num_distance_codes, num_dist_htrees);
for (i = 0; i < 3; ++i) {
hgroup[i].decode(br);
}
context_map_slice = 0;
dist_context_map_slice = 0;
context_mode = context_modes[block_type[0]];
context_lookup_offset1 = Context.lookupOffsets[context_mode];
context_lookup_offset2 = Context.lookupOffsets[context_mode + 1];
htree_command = hgroup[1].htrees[0];
while (meta_block_remaining_len > 0) {
var cmd_code;
var range_idx;
var insert_code;
var copy_code;
var insert_length;
var copy_length;
var distance_code;
var distance;
var context;
var j;
var copy_dst;
br.readMoreInput();
if (block_length[1] === 0) {
DecodeBlockType(num_block_types[1],
block_type_trees, 1, block_type, block_type_rb,
block_type_rb_index, br);
block_length[1] = ReadBlockLength(block_len_trees, HUFFMAN_MAX_TABLE_SIZE, br);
htree_command = hgroup[1].htrees[block_type[1]];
}
--block_length[1];
cmd_code = ReadSymbol(hgroup[1].codes, htree_command, br);
range_idx = cmd_code >> 6;
if (range_idx >= 2) {
range_idx -= 2;
distance_code = -1;
} else {
distance_code = 0;
}
insert_code = Prefix.kInsertRangeLut[range_idx] + ((cmd_code >> 3) & 7);
copy_code = Prefix.kCopyRangeLut[range_idx] + (cmd_code & 7);
insert_length = Prefix.kInsertLengthPrefixCode[insert_code].offset +
br.readBits(Prefix.kInsertLengthPrefixCode[insert_code].nbits);
copy_length = Prefix.kCopyLengthPrefixCode[copy_code].offset +
br.readBits(Prefix.kCopyLengthPrefixCode[copy_code].nbits);
prev_byte1 = ringbuffer[pos-1 & ringbuffer_mask];
prev_byte2 = ringbuffer[pos-2 & ringbuffer_mask];
for (j = 0; j < insert_length; ++j) {
br.readMoreInput();
if (block_length[0] === 0) {
DecodeBlockType(num_block_types[0],
block_type_trees, 0, block_type, block_type_rb,
block_type_rb_index, br);
block_length[0] = ReadBlockLength(block_len_trees, 0, br);
context_offset = block_type[0] << kLiteralContextBits;
context_map_slice = context_offset;
context_mode = context_modes[block_type[0]];
context_lookup_offset1 = Context.lookupOffsets[context_mode];
context_lookup_offset2 = Context.lookupOffsets[context_mode + 1];
}
context = (Context.lookup[context_lookup_offset1 + prev_byte1] |
Context.lookup[context_lookup_offset2 + prev_byte2]);
literal_htree_index = context_map[context_map_slice + context];
--block_length[0];
prev_byte2 = prev_byte1;
prev_byte1 = ReadSymbol(hgroup[0].codes, hgroup[0].htrees[literal_htree_index], br);
ringbuffer[pos & ringbuffer_mask] = prev_byte1;
if ((pos & ringbuffer_mask) === ringbuffer_mask) {
output.write(ringbuffer, ringbuffer_size);
}
++pos;
}
meta_block_remaining_len -= insert_length;
if (meta_block_remaining_len <= 0) break;
if (distance_code < 0) {
var context;
br.readMoreInput();
if (block_length[2] === 0) {
DecodeBlockType(num_block_types[2],
block_type_trees, 2, block_type, block_type_rb,
block_type_rb_index, br);
block_length[2] = ReadBlockLength(block_len_trees, 2 * HUFFMAN_MAX_TABLE_SIZE, br);
dist_context_offset = block_type[2] << kDistanceContextBits;
dist_context_map_slice = dist_context_offset;
}
--block_length[2];
context = (copy_length > 4 ? 3 : copy_length - 2) & 0xff;
dist_htree_index = dist_context_map[dist_context_map_slice + context];
distance_code = ReadSymbol(hgroup[2].codes, hgroup[2].htrees[dist_htree_index], br);
if (distance_code >= num_direct_distance_codes) {
var nbits;
var postfix;
var offset;
distance_code -= num_direct_distance_codes;
postfix = distance_code & distance_postfix_mask;
distance_code >>= distance_postfix_bits;
nbits = (distance_code >> 1) + 1;
offset = ((2 + (distance_code & 1)) << nbits) - 4;
distance_code = num_direct_distance_codes +
((offset + br.readBits(nbits)) <<
distance_postfix_bits) + postfix;
}
}
/* Convert the distance code to the actual distance by possibly looking */
/* up past distnaces from the ringbuffer. */
distance = TranslateShortCodes(distance_code, dist_rb, dist_rb_idx);
if (distance < 0) {
throw new Error('[BrotliDecompress] invalid distance');
}
if (pos < max_backward_distance &&
max_distance !== max_backward_distance) {
max_distance = pos;
} else {
max_distance = max_backward_distance;
}
copy_dst = pos & ringbuffer_mask;
if (distance > max_distance) {
if (copy_length >= BrotliDictionary.minDictionaryWordLength &&
copy_length <= BrotliDictionary.maxDictionaryWordLength) {
var offset = BrotliDictionary.offsetsByLength[copy_length];
var word_id = distance - max_distance - 1;
var shift = BrotliDictionary.sizeBitsByLength[copy_length];
var mask = (1 << shift) - 1;
var word_idx = word_id & mask;
var transform_idx = word_id >> shift;
offset += word_idx * copy_length;
if (transform_idx < Transform.kNumTransforms) {
var len = Transform.transformDictionaryWord(ringbuffer, copy_dst, offset, copy_length, transform_idx);
copy_dst += len;
pos += len;
meta_block_remaining_len -= len;
if (copy_dst >= ringbuffer_end) {
output.write(ringbuffer, ringbuffer_size);
for (var _x = 0; _x < (copy_dst - ringbuffer_end); _x++)
ringbuffer[_x] = ringbuffer[ringbuffer_end + _x];
}
} else {
throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance +
" len: " + copy_length + " bytes left: " + meta_block_remaining_len);
}
} else {
throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance +
" len: " + copy_length + " bytes left: " + meta_block_remaining_len);
}
} else {
if (distance_code > 0) {
dist_rb[dist_rb_idx & 3] = distance;
++dist_rb_idx;
}
if (copy_length > meta_block_remaining_len) {
throw new Error("Invalid backward reference. pos: " + pos + " distance: " + distance +
" len: " + copy_length + " bytes left: " + meta_block_remaining_len);
}
for (j = 0; j < copy_length; ++j) {
ringbuffer[pos & ringbuffer_mask] = ringbuffer[(pos - distance) & ringbuffer_mask];
if ((pos & ringbuffer_mask) === ringbuffer_mask) {
output.write(ringbuffer, ringbuffer_size);
}
++pos;
--meta_block_remaining_len;
}
}
/* When we get here, we must have inserted at least one literal and */
/* made a copy of at least length two, therefore accessing the last 2 */
/* bytes is valid. */
prev_byte1 = ringbuffer[(pos - 1) & ringbuffer_mask];
prev_byte2 = ringbuffer[(pos - 2) & ringbuffer_mask];
}
/* Protect pos from overflow, wrap it around at every GB of input data */
pos &= 0x3fffffff;
}
output.write(ringbuffer, pos & ringbuffer_mask);
}
exports.BrotliDecompress = BrotliDecompress;
BrotliDictionary.init();
},{"./bit_reader":10,"./context":11,"./dictionary":15,"./huffman":16,"./prefix":17,"./streams":18,"./transform":19}],13:[function(require,module,exports){
var base64 = require('base64-js');
/**
* The normal dictionary-data.js is quite large, which makes it
* unsuitable for browser usage. In order to make it smaller,
* we read dictionary.bin, which is a compressed version of
* the dictionary, and on initial load, Brotli decompresses
* it's own dictionary. 😜
*/
exports.init = function() {
var BrotliDecompressBuffer = require('./decode').BrotliDecompressBuffer;
var compressed = base64.toByteArray(require('./dictionary.bin.js'));
return BrotliDecompressBuffer(compressed);
};
},{"./decode":12,"./dictionary.bin.js":14,"base64-js":9}],14:[function(require,module,exports){
module.exports="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";
},{}],15:[function(require,module,exports){
/* Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Collection of static dictionary words.
*/
var data = require('./dictionary-data');
exports.init = function() {
exports.dictionary = data.init();
};
exports.offsetsByLength = new Uint32Array([
0, 0, 0, 0, 0, 4096, 9216, 21504, 35840, 44032,
53248, 63488, 74752, 87040, 93696, 100864, 104704, 106752, 108928, 113536,
115968, 118528, 119872, 121280, 122016,
]);
exports.sizeBitsByLength = new Uint8Array([
0, 0, 0, 0, 10, 10, 11, 11, 10, 10,
10, 10, 10, 9, 9, 8, 7, 7, 8, 7,
7, 6, 6, 5, 5,
]);
exports.minDictionaryWordLength = 4;
exports.maxDictionaryWordLength = 24;
},{"./dictionary-data":13}],16:[function(require,module,exports){
function HuffmanCode(bits, value) {
this.bits = bits; /* number of bits used for this symbol */
this.value = value; /* symbol value or table offset */
}
exports.HuffmanCode = HuffmanCode;
var MAX_LENGTH = 15;
/* Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the
bit-wise reversal of the len least significant bits of key. */
function GetNextKey(key, len) {
var step = 1 << (len - 1);
while (key & step) {
step >>= 1;
}
return (key & (step - 1)) + step;
}
/* Stores code in table[0], table[step], table[2*step], ..., table[end] */
/* Assumes that end is an integer multiple of step */
function ReplicateValue(table, i, step, end, code) {
do {
end -= step;
table[i + end] = new HuffmanCode(code.bits, code.value);
} while (end > 0);
}
/* Returns the table width of the next 2nd level table. count is the histogram
of bit lengths for the remaining symbols, len is the code length of the next
processed symbol */
function NextTableBitSize(count, len, root_bits) {
var left = 1 << (len - root_bits);
while (len < MAX_LENGTH) {
left -= count[len];
if (left <= 0) break;
++len;
left <<= 1;
}
return len - root_bits;
}
exports.BrotliBuildHuffmanTable = function(root_table, table, root_bits, code_lengths, code_lengths_size) {
var start_table = table;
var code; /* current table entry */
var len; /* current code length */
var symbol; /* symbol index in original or sorted table */
var key; /* reversed prefix code */
var step; /* step size to replicate values in current table */
var low; /* low bits for current root entry */
var mask; /* mask for low bits */
var table_bits; /* key length of current table */
var table_size; /* size of current table */
var total_size; /* sum of root table size and 2nd level table sizes */
var sorted; /* symbols sorted by code length */
var count = new Int32Array(MAX_LENGTH + 1); /* number of codes of each length */
var offset = new Int32Array(MAX_LENGTH + 1); /* offsets in sorted table for each length */
sorted = new Int32Array(code_lengths_size);
/* build histogram of code lengths */
for (symbol = 0; symbol < code_lengths_size; symbol++) {
count[code_lengths[symbol]]++;
}
/* generate offsets into sorted symbol table by code length */
offset[1] = 0;
for (len = 1; len < MAX_LENGTH; len++) {
offset[len + 1] = offset[len] + count[len];
}
/* sort symbols by length, by symbol order within each length */
for (symbol = 0; symbol < code_lengths_size; symbol++) {
if (code_lengths[symbol] !== 0) {
sorted[offset[code_lengths[symbol]]++] = symbol;
}
}
table_bits = root_bits;
table_size = 1 << table_bits;
total_size = table_size;
/* special case code with only one value */
if (offset[MAX_LENGTH] === 1) {
for (key = 0; key < total_size; ++key) {
root_table[table + key] = new HuffmanCode(0, sorted[0] & 0xffff);
}
return total_size;
}
/* fill in root table */
key = 0;
symbol = 0;
for (len = 1, step = 2; len <= root_bits; ++len, step <<= 1) {
for (; count[len] > 0; --count[len]) {
code = new HuffmanCode(len & 0xff, sorted[symbol++] & 0xffff);
ReplicateValue(root_table, table + key, step, table_size, code);
key = GetNextKey(key, len);
}
}
/* fill in 2nd level tables and add pointers to root table */
mask = total_size - 1;
low = -1;
for (len = root_bits + 1, step = 2; len <= MAX_LENGTH; ++len, step <<= 1) {
for (; count[len] > 0; --count[len]) {
if ((key & mask) !== low) {
table += table_size;
table_bits = NextTableBitSize(count, len, root_bits);
table_size = 1 << table_bits;
total_size += table_size;
low = key & mask;
root_table[start_table + low] = new HuffmanCode((table_bits + root_bits) & 0xff, ((table - start_table) - low) & 0xffff);
}
code = new HuffmanCode((len - root_bits) & 0xff, sorted[symbol++] & 0xffff);
ReplicateValue(root_table, table + (key >> root_bits), step, table_size, code);
key = GetNextKey(key, len);
}
}
return total_size;
}
},{}],17:[function(require,module,exports){
/* Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Lookup tables to map prefix codes to value ranges. This is used during
decoding of the block lengths, literal insertion lengths and copy lengths.
*/
/* Represents the range of values belonging to a prefix code: */
/* [offset, offset + 2^nbits) */
function PrefixCodeRange(offset, nbits) {
this.offset = offset;
this.nbits = nbits;
}
exports.kBlockLengthPrefixCode = [
new PrefixCodeRange(1, 2), new PrefixCodeRange(5, 2), new PrefixCodeRange(9, 2), new PrefixCodeRange(13, 2),
new PrefixCodeRange(17, 3), new PrefixCodeRange(25, 3), new PrefixCodeRange(33, 3), new PrefixCodeRange(41, 3),
new PrefixCodeRange(49, 4), new PrefixCodeRange(65, 4), new PrefixCodeRange(81, 4), new PrefixCodeRange(97, 4),
new PrefixCodeRange(113, 5), new PrefixCodeRange(145, 5), new PrefixCodeRange(177, 5), new PrefixCodeRange(209, 5),
new PrefixCodeRange(241, 6), new PrefixCodeRange(305, 6), new PrefixCodeRange(369, 7), new PrefixCodeRange(497, 8),
new PrefixCodeRange(753, 9), new PrefixCodeRange(1265, 10), new PrefixCodeRange(2289, 11), new PrefixCodeRange(4337, 12),
new PrefixCodeRange(8433, 13), new PrefixCodeRange(16625, 24)
];
exports.kInsertLengthPrefixCode = [
new PrefixCodeRange(0, 0), new PrefixCodeRange(1, 0), new PrefixCodeRange(2, 0), new PrefixCodeRange(3, 0),
new PrefixCodeRange(4, 0), new PrefixCodeRange(5, 0), new PrefixCodeRange(6, 1), new PrefixCodeRange(8, 1),
new PrefixCodeRange(10, 2), new PrefixCodeRange(14, 2), new PrefixCodeRange(18, 3), new PrefixCodeRange(26, 3),
new PrefixCodeRange(34, 4), new PrefixCodeRange(50, 4), new PrefixCodeRange(66, 5), new PrefixCodeRange(98, 5),
new PrefixCodeRange(130, 6), new PrefixCodeRange(194, 7), new PrefixCodeRange(322, 8), new PrefixCodeRange(578, 9),
new PrefixCodeRange(1090, 10), new PrefixCodeRange(2114, 12), new PrefixCodeRange(6210, 14), new PrefixCodeRange(22594, 24),
];
exports.kCopyLengthPrefixCode = [
new PrefixCodeRange(2, 0), new PrefixCodeRange(3, 0), new PrefixCodeRange(4, 0), new PrefixCodeRange(5, 0),
new PrefixCodeRange(6, 0), new PrefixCodeRange(7, 0), new PrefixCodeRange(8, 0), new PrefixCodeRange(9, 0),
new PrefixCodeRange(10, 1), new PrefixCodeRange(12, 1), new PrefixCodeRange(14, 2), new PrefixCodeRange(18, 2),
new PrefixCodeRange(22, 3), new PrefixCodeRange(30, 3), new PrefixCodeRange(38, 4), new PrefixCodeRange(54, 4),
new PrefixCodeRange(70, 5), new PrefixCodeRange(102, 5), new PrefixCodeRange(134, 6), new PrefixCodeRange(198, 7),
new PrefixCodeRange(326, 8), new PrefixCodeRange(582, 9), new PrefixCodeRange(1094, 10), new PrefixCodeRange(2118, 24),
];
exports.kInsertRangeLut = [
0, 0, 8, 8, 0, 16, 8, 16, 16,
];
exports.kCopyRangeLut = [
0, 8, 0, 8, 16, 0, 16, 8, 16,
];
},{}],18:[function(require,module,exports){
function BrotliInput(buffer) {
this.buffer = buffer;
this.pos = 0;
}
BrotliInput.prototype.read = function(buf, i, count) {
if (this.pos + count > this.buffer.length) {
count = this.buffer.length - this.pos;
}
for (var p = 0; p < count; p++)
buf[i + p] = this.buffer[this.pos + p];
this.pos += count;
return count;
}
exports.BrotliInput = BrotliInput;
function BrotliOutput(buf) {
this.buffer = buf;
this.pos = 0;
}
BrotliOutput.prototype.write = function(buf, count) {
if (this.pos + count > this.buffer.length)
throw new Error('Output buffer is not large enough');
this.buffer.set(buf.subarray(0, count), this.pos);
this.pos += count;
return count;
};
exports.BrotliOutput = BrotliOutput;
},{}],19:[function(require,module,exports){
/* Copyright 2013 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Transformations on dictionary words.
*/
var BrotliDictionary = require('./dictionary');
var kIdentity = 0;
var kOmitLast1 = 1;
var kOmitLast2 = 2;
var kOmitLast3 = 3;
var kOmitLast4 = 4;
var kOmitLast5 = 5;
var kOmitLast6 = 6;
var kOmitLast7 = 7;
var kOmitLast8 = 8;
var kOmitLast9 = 9;
var kUppercaseFirst = 10;
var kUppercaseAll = 11;
var kOmitFirst1 = 12;
var kOmitFirst2 = 13;
var kOmitFirst3 = 14;
var kOmitFirst4 = 15;
var kOmitFirst5 = 16;
var kOmitFirst6 = 17;
var kOmitFirst7 = 18;
var kOmitFirst8 = 19;
var kOmitFirst9 = 20;
function Transform(prefix, transform, suffix) {
this.prefix = new Uint8Array(prefix.length);
this.transform = transform;
this.suffix = new Uint8Array(suffix.length);
for (var i = 0; i < prefix.length; i++)
this.prefix[i] = prefix.charCodeAt(i);
for (var i = 0; i < suffix.length; i++)
this.suffix[i] = suffix.charCodeAt(i);
}
var kTransforms = [
new Transform( "", kIdentity, "" ),
new Transform( "", kIdentity, " " ),
new Transform( " ", kIdentity, " " ),
new Transform( "", kOmitFirst1, "" ),
new Transform( "", kUppercaseFirst, " " ),
new Transform( "", kIdentity, " the " ),
new Transform( " ", kIdentity, "" ),
new Transform( "s ", kIdentity, " " ),
new Transform( "", kIdentity, " of " ),
new Transform( "", kUppercaseFirst, "" ),
new Transform( "", kIdentity, " and " ),
new Transform( "", kOmitFirst2, "" ),
new Transform( "", kOmitLast1, "" ),
new Transform( ", ", kIdentity, " " ),
new Transform( "", kIdentity, ", " ),
new Transform( " ", kUppercaseFirst, " " ),
new Transform( "", kIdentity, " in " ),
new Transform( "", kIdentity, " to " ),
new Transform( "e ", kIdentity, " " ),
new Transform( "", kIdentity, "\"" ),
new Transform( "", kIdentity, "." ),
new Transform( "", kIdentity, "\">" ),
new Transform( "", kIdentity, "\n" ),
new Transform( "", kOmitLast3, "" ),
new Transform( "", kIdentity, "]" ),
new Transform( "", kIdentity, " for " ),
new Transform( "", kOmitFirst3, "" ),
new Transform( "", kOmitLast2, "" ),
new Transform( "", kIdentity, " a " ),
new Transform( "", kIdentity, " that " ),
new Transform( " ", kUppercaseFirst, "" ),
new Transform( "", kIdentity, ". " ),
new Transform( ".", kIdentity, "" ),
new Transform( " ", kIdentity, ", " ),
new Transform( "", kOmitFirst4, "" ),
new Transform( "", kIdentity, " with " ),
new Transform( "", kIdentity, "'" ),
new Transform( "", kIdentity, " from " ),
new Transform( "", kIdentity, " by " ),
new Transform( "", kOmitFirst5, "" ),
new Transform( "", kOmitFirst6, "" ),
new Transform( " the ", kIdentity, "" ),
new Transform( "", kOmitLast4, "" ),
new Transform( "", kIdentity, ". The " ),
new Transform( "", kUppercaseAll, "" ),
new Transform( "", kIdentity, " on " ),
new Transform( "", kIdentity, " as " ),
new Transform( "", kIdentity, " is " ),
new Transform( "", kOmitLast7, "" ),
new Transform( "", kOmitLast1, "ing " ),
new Transform( "", kIdentity, "\n\t" ),
new Transform( "", kIdentity, ":" ),
new Transform( " ", kIdentity, ". " ),
new Transform( "", kIdentity, "ed " ),
new Transform( "", kOmitFirst9, "" ),
new Transform( "", kOmitFirst7, "" ),
new Transform( "", kOmitLast6, "" ),
new Transform( "", kIdentity, "(" ),
new Transform( "", kUppercaseFirst, ", " ),
new Transform( "", kOmitLast8, "" ),
new Transform( "", kIdentity, " at " ),
new Transform( "", kIdentity, "ly " ),
new Transform( " the ", kIdentity, " of " ),
new Transform( "", kOmitLast5, "" ),
new Transform( "", kOmitLast9, "" ),
new Transform( " ", kUppercaseFirst, ", " ),
new Transform( "", kUppercaseFirst, "\"" ),
new Transform( ".", kIdentity, "(" ),
new Transform( "", kUppercaseAll, " " ),
new Transform( "", kUppercaseFirst, "\">" ),
new Transform( "", kIdentity, "=\"" ),
new Transform( " ", kIdentity, "." ),
new Transform( ".com/", kIdentity, "" ),
new Transform( " the ", kIdentity, " of the " ),
new Transform( "", kUppercaseFirst, "'" ),
new Transform( "", kIdentity, ". This " ),
new Transform( "", kIdentity, "," ),
new Transform( ".", kIdentity, " " ),
new Transform( "", kUppercaseFirst, "(" ),
new Transform( "", kUppercaseFirst, "." ),
new Transform( "", kIdentity, " not " ),
new Transform( " ", kIdentity, "=\"" ),
new Transform( "", kIdentity, "er " ),
new Transform( " ", kUppercaseAll, " " ),
new Transform( "", kIdentity, "al " ),
new Transform( " ", kUppercaseAll, "" ),
new Transform( "", kIdentity, "='" ),
new Transform( "", kUppercaseAll, "\"" ),
new Transform( "", kUppercaseFirst, ". " ),
new Transform( " ", kIdentity, "(" ),
new Transform( "", kIdentity, "ful " ),
new Transform( " ", kUppercaseFirst, ". " ),
new Transform( "", kIdentity, "ive " ),
new Transform( "", kIdentity, "less " ),
new Transform( "", kUppercaseAll, "'" ),
new Transform( "", kIdentity, "est " ),
new Transform( " ", kUppercaseFirst, "." ),
new Transform( "", kUppercaseAll, "\">" ),
new Transform( " ", kIdentity, "='" ),
new Transform( "", kUppercaseFirst, "," ),
new Transform( "", kIdentity, "ize " ),
new Transform( "", kUppercaseAll, "." ),
new Transform( "\xc2\xa0", kIdentity, "" ),
new Transform( " ", kIdentity, "," ),
new Transform( "", kUppercaseFirst, "=\"" ),
new Transform( "", kUppercaseAll, "=\"" ),
new Transform( "", kIdentity, "ous " ),
new Transform( "", kUppercaseAll, ", " ),
new Transform( "", kUppercaseFirst, "='" ),
new Transform( " ", kUppercaseFirst, "," ),
new Transform( " ", kUppercaseAll, "=\"" ),
new Transform( " ", kUppercaseAll, ", " ),
new Transform( "", kUppercaseAll, "," ),
new Transform( "", kUppercaseAll, "(" ),
new Transform( "", kUppercaseAll, ". " ),
new Transform( " ", kUppercaseAll, "." ),
new Transform( "", kUppercaseAll, "='" ),
new Transform( " ", kUppercaseAll, ". " ),
new Transform( " ", kUppercaseFirst, "=\"" ),
new Transform( " ", kUppercaseAll, "='" ),
new Transform( " ", kUppercaseFirst, "='" )
];
exports.kTransforms = kTransforms;
exports.kNumTransforms = kTransforms.length;
function ToUpperCase(p, i) {
if (p[i] < 0xc0) {
if (p[i] >= 97 && p[i] <= 122) {
p[i] ^= 32;
}
return 1;
}
/* An overly simplified uppercasing model for utf-8. */
if (p[i] < 0xe0) {
p[i + 1] ^= 32;
return 2;
}
/* An arbitrary transform for three byte characters. */
p[i + 2] ^= 5;
return 3;
}
exports.transformDictionaryWord = function(dst, idx, word, len, transform) {
var prefix = kTransforms[transform].prefix;
var suffix = kTransforms[transform].suffix;
var t = kTransforms[transform].transform;
var skip = t < kOmitFirst1 ? 0 : t - (kOmitFirst1 - 1);
var i = 0;
var start_idx = idx;
var uppercase;
if (skip > len) {
skip = len;
}
var prefix_pos = 0;
while (prefix_pos < prefix.length) {
dst[idx++] = prefix[prefix_pos++];
}
word += skip;
len -= skip;
if (t <= kOmitLast9) {
len -= t;
}
for (i = 0; i < len; i++) {
dst[idx++] = BrotliDictionary.dictionary[word + i];
}
uppercase = idx - len;
if (t === kUppercaseFirst) {
ToUpperCase(dst, uppercase);
} else if (t === kUppercaseAll) {
while (len > 0) {
var step = ToUpperCase(dst, uppercase);
uppercase += step;
len -= step;
}
}
var suffix_pos = 0;
while (suffix_pos < suffix.length) {
dst[idx++] = suffix[suffix_pos++];
}
return idx - start_idx;
}
},{"./dictionary":15}],20:[function(require,module,exports){
module.exports = require('./dec/decode').BrotliDecompressBuffer;
},{"./dec/decode":12}],21:[function(require,module,exports){
(function (Buffer){(function (){
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <https://feross.org>
* @license MIT
*/
/* eslint-disable no-proto */
'use strict'
var base64 = require('base64-js')
var ieee754 = require('ieee754')
exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50
var K_MAX_LENGTH = 0x7fffffff
exports.kMaxLength = K_MAX_LENGTH
/**
* If `Buffer.TYPED_ARRAY_SUPPORT`:
* === true Use Uint8Array implementation (fastest)
* === false Print warning and recommend using `buffer` v4.x which has an Object
* implementation (most compatible, even IE6)
*
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
* Opera 11.6+, iOS 4.2+.
*
* We report that the browser does not support typed arrays if the are not subclassable
* using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
* (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
* for __proto__ and has a buggy typed array implementation.
*/
Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
typeof console.error === 'function') {
console.error(
'This browser lacks typed array (Uint8Array) support which is required by ' +
'`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
)
}
function typedArraySupport () {
// Can typed array instances can be augmented?
try {
var arr = new Uint8Array(1)
arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
return arr.foo() === 42
} catch (e) {
return false
}
}
Object.defineProperty(Buffer.prototype, 'parent', {
enumerable: true,
get: function () {
if (!Buffer.isBuffer(this)) return undefined
return this.buffer
}
})
Object.defineProperty(Buffer.prototype, 'offset', {
enumerable: true,
get: function () {
if (!Buffer.isBuffer(this)) return undefined
return this.byteOffset
}
})
function createBuffer (length) {
if (length > K_MAX_LENGTH) {
throw new RangeError('The value "' + length + '" is invalid for option "size"')
}
// Return an augmented `Uint8Array` instance
var buf = new Uint8Array(length)
buf.__proto__ = Buffer.prototype
return buf
}
/**
* The Buffer constructor returns instances of `Uint8Array` that have their
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
* returns a single octet.
*
* The `Uint8Array` prototype remains unmodified.
*/
function Buffer (arg, encodingOrOffset, length) {
// Common case.
if (typeof arg === 'number') {
if (typeof encodingOrOffset === 'string') {
throw new TypeError(
'The "string" argument must be of type string. Received type number'
)
}
return allocUnsafe(arg)
}
return from(arg, encodingOrOffset, length)
}
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
if (typeof Symbol !== 'undefined' && Symbol.species != null &&
Buffer[Symbol.species] === Buffer) {
Object.defineProperty(Buffer, Symbol.species, {
value: null,
configurable: true,
enumerable: false,
writable: false
})
}
Buffer.poolSize = 8192 // not used by this implementation
function from (value, encodingOrOffset, length) {
if (typeof value === 'string') {
return fromString(value, encodingOrOffset)
}
if (ArrayBuffer.isView(value)) {
return fromArrayLike(value)
}
if (value == null) {
throw TypeError(
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
'or Array-like Object. Received type ' + (typeof value)
)
}
if (isInstance(value, ArrayBuffer) ||
(value && isInstance(value.buffer, ArrayBuffer))) {
return fromArrayBuffer(value, encodingOrOffset, length)
}
if (typeof value === 'number') {
throw new TypeError(
'The "value" argument must not be of type number. Received type number'
)
}
var valueOf = value.valueOf && value.valueOf()
if (valueOf != null && valueOf !== value) {
return Buffer.from(valueOf, encodingOrOffset, length)
}
var b = fromObject(value)
if (b) return b
if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
typeof value[Symbol.toPrimitive] === 'function') {
return Buffer.from(
value[Symbol.toPrimitive]('string'), encodingOrOffset, length
)
}
throw new TypeError(
'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
'or Array-like Object. Received type ' + (typeof value)
)
}
/**
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
* if value is a number.
* Buffer.from(str[, encoding])
* Buffer.from(array)
* Buffer.from(buffer)
* Buffer.from(arrayBuffer[, byteOffset[, length]])
**/
Buffer.from = function (value, encodingOrOffset, length) {
return from(value, encodingOrOffset, length)
}
// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
// https://github.com/feross/buffer/pull/148
Buffer.prototype.__proto__ = Uint8Array.prototype
Buffer.__proto__ = Uint8Array
function assertSize (size) {
if (typeof size !== 'number') {
throw new TypeError('"size" argument must be of type number')
} else if (size < 0) {
throw new RangeError('The value "' + size + '" is invalid for option "size"')
}
}
function alloc (size, fill, encoding) {
assertSize(size)
if (size <= 0) {
return createBuffer(size)
}
if (fill !== undefined) {
// Only pay attention to encoding if it's a string. This
// prevents accidentally sending in a number that would
// be interpretted as a start offset.
return typeof encoding === 'string'
? createBuffer(size).fill(fill, encoding)
: createBuffer(size).fill(fill)
}
return createBuffer(size)
}
/**
* Creates a new filled Buffer instance.
* alloc(size[, fill[, encoding]])
**/
Buffer.alloc = function (size, fill, encoding) {
return alloc(size, fill, encoding)
}
function allocUnsafe (size) {
assertSize(size)
return createBuffer(size < 0 ? 0 : checked(size) | 0)
}
/**
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
* */
Buffer.allocUnsafe = function (size) {
return allocUnsafe(size)
}
/**
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
*/
Buffer.allocUnsafeSlow = function (size) {
return allocUnsafe(size)
}
function fromString (string, encoding) {
if (typeof encoding !== 'string' || encoding === '') {
encoding = 'utf8'
}
if (!Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
var length = byteLength(string, encoding) | 0
var buf = createBuffer(length)
var actual = buf.write(string, encoding)
if (actual !== length) {
// Writing a hex string, for example, that contains invalid characters will
// cause everything after the first invalid character to be ignored. (e.g.
// 'abxxcd' will be treated as 'ab')
buf = buf.slice(0, actual)
}
return buf
}
function fromArrayLike (array) {
var length = array.length < 0 ? 0 : checked(array.length) | 0
var buf = createBuffer(length)
for (var i = 0; i < length; i += 1) {
buf[i] = array[i] & 255
}
return buf
}
function fromArrayBuffer (array, byteOffset, length) {
if (byteOffset < 0 || array.byteLength < byteOffset) {
throw new RangeError('"offset" is outside of buffer bounds')
}
if (array.byteLength < byteOffset + (length || 0)) {
throw new RangeError('"length" is outside of buffer bounds')
}
var buf
if (byteOffset === undefined && length === undefined) {
buf = new Uint8Array(array)
} else if (length === undefined) {
buf = new Uint8Array(array, byteOffset)
} else {
buf = new Uint8Array(array, byteOffset, length)
}
// Return an augmented `Uint8Array` instance
buf.__proto__ = Buffer.prototype
return buf
}
function fromObject (obj) {
if (Buffer.isBuffer(obj)) {
var len = checked(obj.length) | 0
var buf = createBuffer(len)
if (buf.length === 0) {
return buf
}
obj.copy(buf, 0, 0, len)
return buf
}
if (obj.length !== undefined) {
if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
return createBuffer(0)
}
return fromArrayLike(obj)
}
if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
return fromArrayLike(obj.data)
}
}
function checked (length) {
// Note: cannot use `length < K_MAX_LENGTH` here because that fails when
// length is NaN (which is otherwise coerced to zero.)
if (length >= K_MAX_LENGTH) {
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
}
return length | 0
}
function SlowBuffer (length) {
if (+length != length) { // eslint-disable-line eqeqeq
length = 0
}
return Buffer.alloc(+length)
}
Buffer.isBuffer = function isBuffer (b) {
return b != null && b._isBuffer === true &&
b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
}
Buffer.compare = function compare (a, b) {
if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
throw new TypeError(
'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
)
}
if (a === b) return 0
var x = a.length
var y = b.length
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
if (a[i] !== b[i]) {
x = a[i]
y = b[i]
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
}
Buffer.isEncoding = function isEncoding (encoding) {
switch (String(encoding).toLowerCase()) {
case 'hex':
case 'utf8':
case 'utf-8':
case 'ascii':
case 'latin1':
case 'binary':
case 'base64':
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return true
default:
return false
}
}
Buffer.concat = function concat (list, length) {
if (!Array.isArray(list)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
if (list.length === 0) {
return Buffer.alloc(0)
}
var i
if (length === undefined) {
length = 0
for (i = 0; i < list.length; ++i) {
length += list[i].length
}
}
var buffer = Buffer.allocUnsafe(length)
var pos = 0
for (i = 0; i < list.length; ++i) {
var buf = list[i]
if (isInstance(buf, Uint8Array)) {
buf = Buffer.from(buf)
}
if (!Buffer.isBuffer(buf)) {
throw new TypeError('"list" argument must be an Array of Buffers')
}
buf.copy(buffer, pos)
pos += buf.length
}
return buffer
}
function byteLength (string, encoding) {
if (Buffer.isBuffer(string)) {
return string.length
}
if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
return string.byteLength
}
if (typeof string !== 'string') {
throw new TypeError(
'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
'Received type ' + typeof string
)
}
var len = string.length
var mustMatch = (arguments.length > 2 && arguments[2] === true)
if (!mustMatch && len === 0) return 0
// Use a for loop to avoid recursion
var loweredCase = false
for (;;) {
switch (encoding) {
case 'ascii':
case 'latin1':
case 'binary':
return len
case 'utf8':
case 'utf-8':
return utf8ToBytes(string).length
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return len * 2
case 'hex':
return len >>> 1
case 'base64':
return base64ToBytes(string).length
default:
if (loweredCase) {
return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
}
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
Buffer.byteLength = byteLength
function slowToString (encoding, start, end) {
var loweredCase = false
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
// property of a typed array.
// This behaves neither like String nor Uint8Array in that we set start/end
// to their upper/lower bounds if the value passed is out of range.
// undefined is handled specially as per ECMA-262 6th Edition,
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
if (start === undefined || start < 0) {
start = 0
}
// Return early if start > this.length. Done here to prevent potential uint32
// coercion fail below.
if (start > this.length) {
return ''
}
if (end === undefined || end > this.length) {
end = this.length
}
if (end <= 0) {
return ''
}
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
end >>>= 0
start >>>= 0
if (end <= start) {
return ''
}
if (!encoding) encoding = 'utf8'
while (true) {
switch (encoding) {
case 'hex':
return hexSlice(this, start, end)
case 'utf8':
case 'utf-8':
return utf8Slice(this, start, end)
case 'ascii':
return asciiSlice(this, start, end)
case 'latin1':
case 'binary':
return latin1Slice(this, start, end)
case 'base64':
return base64Slice(this, start, end)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return utf16leSlice(this, start, end)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = (encoding + '').toLowerCase()
loweredCase = true
}
}
}
// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
// reliably in a browserify context because there could be multiple different
// copies of the 'buffer' package in use. This method works even for Buffer
// instances that were created from another copy of the `buffer` package.
// See: https://github.com/feross/buffer/issues/154
Buffer.prototype._isBuffer = true
function swap (b, n, m) {
var i = b[n]
b[n] = b[m]
b[m] = i
}
Buffer.prototype.swap16 = function swap16 () {
var len = this.length
if (len % 2 !== 0) {
throw new RangeError('Buffer size must be a multiple of 16-bits')
}
for (var i = 0; i < len; i += 2) {
swap(this, i, i + 1)
}
return this
}
Buffer.prototype.swap32 = function swap32 () {
var len = this.length
if (len % 4 !== 0) {
throw new RangeError('Buffer size must be a multiple of 32-bits')
}
for (var i = 0; i < len; i += 4) {
swap(this, i, i + 3)
swap(this, i + 1, i + 2)
}
return this
}
Buffer.prototype.swap64 = function swap64 () {
var len = this.length
if (len % 8 !== 0) {
throw new RangeError('Buffer size must be a multiple of 64-bits')
}
for (var i = 0; i < len; i += 8) {
swap(this, i, i + 7)
swap(this, i + 1, i + 6)
swap(this, i + 2, i + 5)
swap(this, i + 3, i + 4)
}
return this
}
Buffer.prototype.toString = function toString () {
var length = this.length
if (length === 0) return ''
if (arguments.length === 0) return utf8Slice(this, 0, length)
return slowToString.apply(this, arguments)
}
Buffer.prototype.toLocaleString = Buffer.prototype.toString
Buffer.prototype.equals = function equals (b) {
if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
if (this === b) return true
return Buffer.compare(this, b) === 0
}
Buffer.prototype.inspect = function inspect () {
var str = ''
var max = exports.INSPECT_MAX_BYTES
str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
if (this.length > max) str += ' ... '
return '<Buffer ' + str + '>'
}
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
if (isInstance(target, Uint8Array)) {
target = Buffer.from(target, target.offset, target.byteLength)
}
if (!Buffer.isBuffer(target)) {
throw new TypeError(
'The "target" argument must be one of type Buffer or Uint8Array. ' +
'Received type ' + (typeof target)
)
}
if (start === undefined) {
start = 0
}
if (end === undefined) {
end = target ? target.length : 0
}
if (thisStart === undefined) {
thisStart = 0
}
if (thisEnd === undefined) {
thisEnd = this.length
}
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
throw new RangeError('out of range index')
}
if (thisStart >= thisEnd && start >= end) {
return 0
}
if (thisStart >= thisEnd) {
return -1
}
if (start >= end) {
return 1
}
start >>>= 0
end >>>= 0
thisStart >>>= 0
thisEnd >>>= 0
if (this === target) return 0
var x = thisEnd - thisStart
var y = end - start
var len = Math.min(x, y)
var thisCopy = this.slice(thisStart, thisEnd)
var targetCopy = target.slice(start, end)
for (var i = 0; i < len; ++i) {
if (thisCopy[i] !== targetCopy[i]) {
x = thisCopy[i]
y = targetCopy[i]
break
}
}
if (x < y) return -1
if (y < x) return 1
return 0
}
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
// Empty buffer means no match
if (buffer.length === 0) return -1
// Normalize byteOffset
if (typeof byteOffset === 'string') {
encoding = byteOffset
byteOffset = 0
} else if (byteOffset > 0x7fffffff) {
byteOffset = 0x7fffffff
} else if (byteOffset < -0x80000000) {
byteOffset = -0x80000000
}
byteOffset = +byteOffset // Coerce to Number.
if (numberIsNaN(byteOffset)) {
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
byteOffset = dir ? 0 : (buffer.length - 1)
}
// Normalize byteOffset: negative offsets start from the end of the buffer
if (byteOffset < 0) byteOffset = buffer.length + byteOffset
if (byteOffset >= buffer.length) {
if (dir) return -1
else byteOffset = buffer.length - 1
} else if (byteOffset < 0) {
if (dir) byteOffset = 0
else return -1
}
// Normalize val
if (typeof val === 'string') {
val = Buffer.from(val, encoding)
}
// Finally, search either indexOf (if dir is true) or lastIndexOf
if (Buffer.isBuffer(val)) {
// Special case: looking for empty string/buffer always fails
if (val.length === 0) {
return -1
}
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
} else if (typeof val === 'number') {
val = val & 0xFF // Search for a byte value [0-255]
if (typeof Uint8Array.prototype.indexOf === 'function') {
if (dir) {
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
} else {
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
}
}
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}
throw new TypeError('val must be string, number or Buffer')
}
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
var indexSize = 1
var arrLength = arr.length
var valLength = val.length
if (encoding !== undefined) {
encoding = String(encoding).toLowerCase()
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
encoding === 'utf16le' || encoding === 'utf-16le') {
if (arr.length < 2 || val.length < 2) {
return -1
}
indexSize = 2
arrLength /= 2
valLength /= 2
byteOffset /= 2
}
}
function read (buf, i) {
if (indexSize === 1) {
return buf[i]
} else {
return buf.readUInt16BE(i * indexSize)
}
}
var i
if (dir) {
var foundIndex = -1
for (i = byteOffset; i < arrLength; i++) {
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
if (foundIndex === -1) foundIndex = i
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
} else {
if (foundIndex !== -1) i -= i - foundIndex
foundIndex = -1
}
}
} else {
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
for (i = byteOffset; i >= 0; i--) {
var found = true
for (var j = 0; j < valLength; j++) {
if (read(arr, i + j) !== read(val, j)) {
found = false
break
}
}
if (found) return i
}
}
return -1
}
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
return this.indexOf(val, byteOffset, encoding) !== -1
}
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}
function hexWrite (buf, string, offset, length) {
offset = Number(offset) || 0
var remaining = buf.length - offset
if (!length) {
length = remaining
} else {
length = Number(length)
if (length > remaining) {
length = remaining
}
}
var strLen = string.length
if (length > strLen / 2) {
length = strLen / 2
}
for (var i = 0; i < length; ++i) {
var parsed = parseInt(string.substr(i * 2, 2), 16)
if (numberIsNaN(parsed)) return i
buf[offset + i] = parsed
}
return i
}
function utf8Write (buf, string, offset, length) {
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}
function asciiWrite (buf, string, offset, length) {
return blitBuffer(asciiToBytes(string), buf, offset, length)
}
function latin1Write (buf, string, offset, length) {
return asciiWrite(buf, string, offset, length)
}
function base64Write (buf, string, offset, length) {
return blitBuffer(base64ToBytes(string), buf, offset, length)
}
function ucs2Write (buf, string, offset, length) {
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}
Buffer.prototype.write = function write (string, offset, length, encoding) {
// Buffer#write(string)
if (offset === undefined) {
encoding = 'utf8'
length = this.length
offset = 0
// Buffer#write(string, encoding)
} else if (length === undefined && typeof offset === 'string') {
encoding = offset
length = this.length
offset = 0
// Buffer#write(string, offset[, length][, encoding])
} else if (isFinite(offset)) {
offset = offset >>> 0
if (isFinite(length)) {
length = length >>> 0
if (encoding === undefined) encoding = 'utf8'
} else {
encoding = length
length = undefined
}
} else {
throw new Error(
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
)
}
var remaining = this.length - offset
if (length === undefined || length > remaining) length = remaining
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
throw new RangeError('Attempt to write outside buffer bounds')
}
if (!encoding) encoding = 'utf8'
var loweredCase = false
for (;;) {
switch (encoding) {
case 'hex':
return hexWrite(this, string, offset, length)
case 'utf8':
case 'utf-8':
return utf8Write(this, string, offset, length)
case 'ascii':
return asciiWrite(this, string, offset, length)
case 'latin1':
case 'binary':
return latin1Write(this, string, offset, length)
case 'base64':
// Warning: maxLength not taken into account in base64Write
return base64Write(this, string, offset, length)
case 'ucs2':
case 'ucs-2':
case 'utf16le':
case 'utf-16le':
return ucs2Write(this, string, offset, length)
default:
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
encoding = ('' + encoding).toLowerCase()
loweredCase = true
}
}
}
Buffer.prototype.toJSON = function toJSON () {
return {
type: 'Buffer',
data: Array.prototype.slice.call(this._arr || this, 0)
}
}
function base64Slice (buf, start, end) {
if (start === 0 && end === buf.length) {
return base64.fromByteArray(buf)
} else {
return base64.fromByteArray(buf.slice(start, end))
}
}
function utf8Slice (buf, start, end) {
end = Math.min(buf.length, end)
var res = []
var i = start
while (i < end) {
var firstByte = buf[i]
var codePoint = null
var bytesPerSequence = (firstByte > 0xEF) ? 4
: (firstByte > 0xDF) ? 3
: (firstByte > 0xBF) ? 2
: 1
if (i + bytesPerSequence <= end) {
var secondByte, thirdByte, fourthByte, tempCodePoint
switch (bytesPerSequence) {
case 1:
if (firstByte < 0x80) {
codePoint = firstByte
}
break
case 2:
secondByte = buf[i + 1]
if ((secondByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
if (tempCodePoint > 0x7F) {
codePoint = tempCodePoint
}
}
break
case 3:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
codePoint = tempCodePoint
}
}
break
case 4:
secondByte = buf[i + 1]
thirdByte = buf[i + 2]
fourthByte = buf[i + 3]
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
codePoint = tempCodePoint
}
}
}
}
if (codePoint === null) {
// we did not generate a valid codePoint so insert a
// replacement char (U+FFFD) and advance only 1 byte
codePoint = 0xFFFD
bytesPerSequence = 1
} else if (codePoint > 0xFFFF) {
// encode to utf16 (surrogate pair dance)
codePoint -= 0x10000
res.push(codePoint >>> 10 & 0x3FF | 0xD800)
codePoint = 0xDC00 | codePoint & 0x3FF
}
res.push(codePoint)
i += bytesPerSequence
}
return decodeCodePointsArray(res)
}
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000
function decodeCodePointsArray (codePoints) {
var len = codePoints.length
if (len <= MAX_ARGUMENTS_LENGTH) {
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
}
// Decode in chunks to avoid "call stack size exceeded".
var res = ''
var i = 0
while (i < len) {
res += String.fromCharCode.apply(
String,
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
)
}
return res
}
function asciiSlice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i] & 0x7F)
}
return ret
}
function latin1Slice (buf, start, end) {
var ret = ''
end = Math.min(buf.length, end)
for (var i = start; i < end; ++i) {
ret += String.fromCharCode(buf[i])
}
return ret
}
function hexSlice (buf, start, end) {
var len = buf.length
if (!start || start < 0) start = 0
if (!end || end < 0 || end > len) end = len
var out = ''
for (var i = start; i < end; ++i) {
out += toHex(buf[i])
}
return out
}
function utf16leSlice (buf, start, end) {
var bytes = buf.slice(start, end)
var res = ''
for (var i = 0; i < bytes.length; i += 2) {
res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
}
return res
}
Buffer.prototype.slice = function slice (start, end) {
var len = this.length
start = ~~start
end = end === undefined ? len : ~~end
if (start < 0) {
start += len
if (start < 0) start = 0
} else if (start > len) {
start = len
}
if (end < 0) {
end += len
if (end < 0) end = 0
} else if (end > len) {
end = len
}
if (end < start) end = start
var newBuf = this.subarray(start, end)
// Return an augmented `Uint8Array` instance
newBuf.__proto__ = Buffer.prototype
return newBuf
}
/*
* Need to make sure that buffer isn't trying to write out of bounds.
*/
function checkOffset (offset, ext, length) {
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
return val
}
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) {
checkOffset(offset, byteLength, this.length)
}
var val = this[offset + --byteLength]
var mul = 1
while (byteLength > 0 && (mul *= 0x100)) {
val += this[offset + --byteLength] * mul
}
return val
}
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 1, this.length)
return this[offset]
}
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
return this[offset] | (this[offset + 1] << 8)
}
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
return (this[offset] << 8) | this[offset + 1]
}
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return ((this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16)) +
(this[offset + 3] * 0x1000000)
}
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] * 0x1000000) +
((this[offset + 1] << 16) |
(this[offset + 2] << 8) |
this[offset + 3])
}
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var val = this[offset]
var mul = 1
var i = 0
while (++i < byteLength && (mul *= 0x100)) {
val += this[offset + i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) checkOffset(offset, byteLength, this.length)
var i = byteLength
var mul = 1
var val = this[offset + --i]
while (i > 0 && (mul *= 0x100)) {
val += this[offset + --i] * mul
}
mul *= 0x80
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
return val
}
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 1, this.length)
if (!(this[offset] & 0x80)) return (this[offset])
return ((0xff - this[offset] + 1) * -1)
}
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset] | (this[offset + 1] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 2, this.length)
var val = this[offset + 1] | (this[offset] << 8)
return (val & 0x8000) ? val | 0xFFFF0000 : val
}
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset]) |
(this[offset + 1] << 8) |
(this[offset + 2] << 16) |
(this[offset + 3] << 24)
}
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return (this[offset] << 24) |
(this[offset + 1] << 16) |
(this[offset + 2] << 8) |
(this[offset + 3])
}
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, true, 23, 4)
}
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 4, this.length)
return ieee754.read(this, offset, false, 23, 4)
}
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, true, 52, 8)
}
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
offset = offset >>> 0
if (!noAssert) checkOffset(offset, 8, this.length)
return ieee754.read(this, offset, false, 52, 8)
}
function checkInt (buf, value, offset, ext, max, min) {
if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
if (offset + ext > buf.length) throw new RangeError('Index out of range')
}
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 0)
}
var mul = 1
var i = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
byteLength = byteLength >>> 0
if (!noAssert) {
var maxBytes = Math.pow(2, 8 * byteLength) - 1
checkInt(this, value, offset, byteLength, maxBytes, 0)
}
var i = byteLength - 1
var mul = 1
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
this[offset + i] = (value / mul) & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
this[offset] = (value & 0xff)
return offset + 1
}
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
return offset + 2
}
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
this[offset] = (value >>> 8)
this[offset + 1] = (value & 0xff)
return offset + 2
}
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
this[offset + 3] = (value >>> 24)
this[offset + 2] = (value >>> 16)
this[offset + 1] = (value >>> 8)
this[offset] = (value & 0xff)
return offset + 4
}
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = (value & 0xff)
return offset + 4
}
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
var limit = Math.pow(2, (8 * byteLength) - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = 0
var mul = 1
var sub = 0
this[offset] = value & 0xFF
while (++i < byteLength && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
var limit = Math.pow(2, (8 * byteLength) - 1)
checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
var i = byteLength - 1
var mul = 1
var sub = 0
this[offset + i] = value & 0xFF
while (--i >= 0 && (mul *= 0x100)) {
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
sub = 1
}
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
return offset + byteLength
}
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
if (value < 0) value = 0xff + value + 1
this[offset] = (value & 0xff)
return offset + 1
}
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
return offset + 2
}
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
this[offset] = (value >>> 8)
this[offset + 1] = (value & 0xff)
return offset + 2
}
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
this[offset] = (value & 0xff)
this[offset + 1] = (value >>> 8)
this[offset + 2] = (value >>> 16)
this[offset + 3] = (value >>> 24)
return offset + 4
}
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
if (value < 0) value = 0xffffffff + value + 1
this[offset] = (value >>> 24)
this[offset + 1] = (value >>> 16)
this[offset + 2] = (value >>> 8)
this[offset + 3] = (value & 0xff)
return offset + 4
}
function checkIEEE754 (buf, value, offset, ext, max, min) {
if (offset + ext > buf.length) throw new RangeError('Index out of range')
if (offset < 0) throw new RangeError('Index out of range')
}
function writeFloat (buf, value, offset, littleEndian, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
}
ieee754.write(buf, value, offset, littleEndian, 23, 4)
return offset + 4
}
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
return writeFloat(this, value, offset, true, noAssert)
}
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
return writeFloat(this, value, offset, false, noAssert)
}
function writeDouble (buf, value, offset, littleEndian, noAssert) {
value = +value
offset = offset >>> 0
if (!noAssert) {
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
}
ieee754.write(buf, value, offset, littleEndian, 52, 8)
return offset + 8
}
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
return writeDouble(this, value, offset, true, noAssert)
}
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
return writeDouble(this, value, offset, false, noAssert)
}
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
if (!start) start = 0
if (!end && end !== 0) end = this.length
if (targetStart >= target.length) targetStart = target.length
if (!targetStart) targetStart = 0
if (end > 0 && end < start) end = start
// Copy 0 bytes; we're done
if (end === start) return 0
if (target.length === 0 || this.length === 0) return 0
// Fatal error conditions
if (targetStart < 0) {
throw new RangeError('targetStart out of bounds')
}
if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
if (end < 0) throw new RangeError('sourceEnd out of bounds')
// Are we oob?
if (end > this.length) end = this.length
if (target.length - targetStart < end - start) {
end = target.length - targetStart + start
}
var len = end - start
if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
// Use built-in when available, missing from IE11
this.copyWithin(targetStart, start, end)
} else if (this === target && start < targetStart && targetStart < end) {
// descending copy from end
for (var i = len - 1; i >= 0; --i) {
target[i + targetStart] = this[i + start]
}
} else {
Uint8Array.prototype.set.call(
target,
this.subarray(start, end),
targetStart
)
}
return len
}
// Usage:
// buffer.fill(number[, offset[, end]])
// buffer.fill(buffer[, offset[, end]])
// buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
// Handle string cases:
if (typeof val === 'string') {
if (typeof start === 'string') {
encoding = start
start = 0
end = this.length
} else if (typeof end === 'string') {
encoding = end
end = this.length
}
if (encoding !== undefined && typeof encoding !== 'string') {
throw new TypeError('encoding must be a string')
}
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
throw new TypeError('Unknown encoding: ' + encoding)
}
if (val.length === 1) {
var code = val.charCodeAt(0)
if ((encoding === 'utf8' && code < 128) ||
encoding === 'latin1') {
// Fast path: If `val` fits into a single byte, use that numeric value.
val = code
}
}
} else if (typeof val === 'number') {
val = val & 255
}
// Invalid ranges are not set to a default, so can range check early.
if (start < 0 || this.length < start || this.length < end) {
throw new RangeError('Out of range index')
}
if (end <= start) {
return this
}
start = start >>> 0
end = end === undefined ? this.length : end >>> 0
if (!val) val = 0
var i
if (typeof val === 'number') {
for (i = start; i < end; ++i) {
this[i] = val
}
} else {
var bytes = Buffer.isBuffer(val)
? val
: Buffer.from(val, encoding)
var len = bytes.length
if (len === 0) {
throw new TypeError('The value "' + val +
'" is invalid for argument "value"')
}
for (i = 0; i < end - start; ++i) {
this[i + start] = bytes[i % len]
}
}
return this
}
// HELPER FUNCTIONS
// ================
var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
function base64clean (str) {
// Node takes equal signs as end of the Base64 encoding
str = str.split('=')[0]
// Node strips out invalid characters like \n and \t from the string, base64-js does not
str = str.trim().replace(INVALID_BASE64_RE, '')
// Node converts strings with length < 2 to ''
if (str.length < 2) return ''
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
while (str.length % 4 !== 0) {
str = str + '='
}
return str
}
function toHex (n) {
if (n < 16) return '0' + n.toString(16)
return n.toString(16)
}
function utf8ToBytes (string, units) {
units = units || Infinity
var codePoint
var length = string.length
var leadSurrogate = null
var bytes = []
for (var i = 0; i < length; ++i) {
codePoint = string.charCodeAt(i)
// is surrogate component
if (codePoint > 0xD7FF && codePoint < 0xE000) {
// last char was a lead
if (!leadSurrogate) {
// no lead yet
if (codePoint > 0xDBFF) {
// unexpected trail
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
} else if (i + 1 === length) {
// unpaired lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
continue
}
// valid lead
leadSurrogate = codePoint
continue
}
// 2 leads in a row
if (codePoint < 0xDC00) {
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
leadSurrogate = codePoint
continue
}
// valid surrogate pair
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
} else if (leadSurrogate) {
// valid bmp char, but last char was a lead
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
}
leadSurrogate = null
// encode utf8
if (codePoint < 0x80) {
if ((units -= 1) < 0) break
bytes.push(codePoint)
} else if (codePoint < 0x800) {
if ((units -= 2) < 0) break
bytes.push(
codePoint >> 0x6 | 0xC0,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x10000) {
if ((units -= 3) < 0) break
bytes.push(
codePoint >> 0xC | 0xE0,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else if (codePoint < 0x110000) {
if ((units -= 4) < 0) break
bytes.push(
codePoint >> 0x12 | 0xF0,
codePoint >> 0xC & 0x3F | 0x80,
codePoint >> 0x6 & 0x3F | 0x80,
codePoint & 0x3F | 0x80
)
} else {
throw new Error('Invalid code point')
}
}
return bytes
}
function asciiToBytes (str) {
var byteArray = []
for (var i = 0; i < str.length; ++i) {
// Node's code seems to be doing this and not & 0x7F..
byteArray.push(str.charCodeAt(i) & 0xFF)
}
return byteArray
}
function utf16leToBytes (str, units) {
var c, hi, lo
var byteArray = []
for (var i = 0; i < str.length; ++i) {
if ((units -= 2) < 0) break
c = str.charCodeAt(i)
hi = c >> 8
lo = c % 256
byteArray.push(lo)
byteArray.push(hi)
}
return byteArray
}
function base64ToBytes (str) {
return base64.toByteArray(base64clean(str))
}
function blitBuffer (src, dst, offset, length) {
for (var i = 0; i < length; ++i) {
if ((i + offset >= dst.length) || (i >= src.length)) break
dst[i + offset] = src[i]
}
return i
}
// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
// the `instanceof` check but they should be treated as of that type.
// See: https://github.com/feross/buffer/issues/166
function isInstance (obj, type) {
return obj instanceof type ||
(obj != null && obj.constructor != null && obj.constructor.name != null &&
obj.constructor.name === type.name)
}
function numberIsNaN (obj) {
// For IE11 support
return obj !== obj // eslint-disable-line no-self-compare
}
}).call(this)}).call(this,require("buffer").Buffer)
},{"base64-js":9,"buffer":21,"ieee754":28}],22:[function(require,module,exports){
(function (Buffer){(function (){
var clone = (function() {
'use strict';
function _instanceof(obj, type) {
return type != null && obj instanceof type;
}
var nativeMap;
try {
nativeMap = Map;
} catch(_) {
// maybe a reference error because no `Map`. Give it a dummy value that no
// value will ever be an instanceof.
nativeMap = function() {};
}
var nativeSet;
try {
nativeSet = Set;
} catch(_) {
nativeSet = function() {};
}
var nativePromise;
try {
nativePromise = Promise;
} catch(_) {
nativePromise = function() {};
}
/**
* Clones (copies) an Object using deep copying.
*
* This function supports circular references by default, but if you are certain
* there are no circular references in your object, you can save some CPU time
* by calling clone(obj, false).
*
* Caution: if `circular` is false and `parent` contains circular references,
* your program may enter an infinite loop and crash.
*
* @param `parent` - the object to be cloned
* @param `circular` - set to true if the object to be cloned may contain
* circular references. (optional - true by default)
* @param `depth` - set to a number if the object is only to be cloned to
* a particular depth. (optional - defaults to Infinity)
* @param `prototype` - sets the prototype to be used when cloning an object.
* (optional - defaults to parent prototype).
* @param `includeNonEnumerable` - set to true if the non-enumerable properties
* should be cloned as well. Non-enumerable properties on the prototype
* chain will be ignored. (optional - false by default)
*/
function clone(parent, circular, depth, prototype, includeNonEnumerable) {
if (typeof circular === 'object') {
depth = circular.depth;
prototype = circular.prototype;
includeNonEnumerable = circular.includeNonEnumerable;
circular = circular.circular;
}
// maintain two arrays for circular references, where corresponding parents
// and children have the same index
var allParents = [];
var allChildren = [];
var useBuffer = typeof Buffer != 'undefined';
if (typeof circular == 'undefined')
circular = true;
if (typeof depth == 'undefined')
depth = Infinity;
// recurse this function so we don't reset allParents and allChildren
function _clone(parent, depth) {
// cloning null always returns null
if (parent === null)
return null;
if (depth === 0)
return parent;
var child;
var proto;
if (typeof parent != 'object') {
return parent;
}
if (_instanceof(parent, nativeMap)) {
child = new nativeMap();
} else if (_instanceof(parent, nativeSet)) {
child = new nativeSet();
} else if (_instanceof(parent, nativePromise)) {
child = new nativePromise(function (resolve, reject) {
parent.then(function(value) {
resolve(_clone(value, depth - 1));
}, function(err) {
reject(_clone(err, depth - 1));
});
});
} else if (clone.__isArray(parent)) {
child = [];
} else if (clone.__isRegExp(parent)) {
child = new RegExp(parent.source, __getRegExpFlags(parent));
if (parent.lastIndex) child.lastIndex = parent.lastIndex;
} else if (clone.__isDate(parent)) {
child = new Date(parent.getTime());
} else if (useBuffer && Buffer.isBuffer(parent)) {
if (Buffer.allocUnsafe) {
// Node.js >= 4.5.0
child = Buffer.allocUnsafe(parent.length);
} else {
// Older Node.js versions
child = new Buffer(parent.length);
}
parent.copy(child);
return child;
} else if (_instanceof(parent, Error)) {
child = Object.create(parent);
} else {
if (typeof prototype == 'undefined') {
proto = Object.getPrototypeOf(parent);
child = Object.create(proto);
}
else {
child = Object.create(prototype);
proto = prototype;
}
}
if (circular) {
var index = allParents.indexOf(parent);
if (index != -1) {
return allChildren[index];
}
allParents.push(parent);
allChildren.push(child);
}
if (_instanceof(parent, nativeMap)) {
parent.forEach(function(value, key) {
var keyChild = _clone(key, depth - 1);
var valueChild = _clone(value, depth - 1);
child.set(keyChild, valueChild);
});
}
if (_instanceof(parent, nativeSet)) {
parent.forEach(function(value) {
var entryChild = _clone(value, depth - 1);
child.add(entryChild);
});
}
for (var i in parent) {
var attrs;
if (proto) {
attrs = Object.getOwnPropertyDescriptor(proto, i);
}
if (attrs && attrs.set == null) {
continue;
}
child[i] = _clone(parent[i], depth - 1);
}
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(parent);
for (var i = 0; i < symbols.length; i++) {
// Don't need to worry about cloning a symbol because it is a primitive,
// like a number or string.
var symbol = symbols[i];
var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
continue;
}
child[symbol] = _clone(parent[symbol], depth - 1);
if (!descriptor.enumerable) {
Object.defineProperty(child, symbol, {
enumerable: false
});
}
}
}
if (includeNonEnumerable) {
var allPropertyNames = Object.getOwnPropertyNames(parent);
for (var i = 0; i < allPropertyNames.length; i++) {
var propertyName = allPropertyNames[i];
var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);
if (descriptor && descriptor.enumerable) {
continue;
}
child[propertyName] = _clone(parent[propertyName], depth - 1);
Object.defineProperty(child, propertyName, {
enumerable: false
});
}
}
return child;
}
return _clone(parent, depth);
}
/**
* Simple flat clone using prototype, accepts only objects, usefull for property
* override on FLAT configuration object (no nested props).
*
* USE WITH CAUTION! This may not behave as you wish if you do not know how this
* works.
*/
clone.clonePrototype = function clonePrototype(parent) {
if (parent === null)
return null;
var c = function () {};
c.prototype = parent;
return new c();
};
// private utility functions
function __objToStr(o) {
return Object.prototype.toString.call(o);
}
clone.__objToStr = __objToStr;
function __isDate(o) {
return typeof o === 'object' && __objToStr(o) === '[object Date]';
}
clone.__isDate = __isDate;
function __isArray(o) {
return typeof o === 'object' && __objToStr(o) === '[object Array]';
}
clone.__isArray = __isArray;
function __isRegExp(o) {
return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
}
clone.__isRegExp = __isRegExp;
function __getRegExpFlags(re) {
var flags = '';
if (re.global) flags += 'g';
if (re.ignoreCase) flags += 'i';
if (re.multiline) flags += 'm';
return flags;
}
clone.__getRegExpFlags = __getRegExpFlags;
return clone;
})();
if (typeof module === 'object' && module.exports) {
module.exports = clone;
}
}).call(this)}).call(this,require("buffer").Buffer)
},{"buffer":21}],23:[function(require,module,exports){
'use strict';
var INITIAL_STATE = 1;
var FAIL_STATE = 0;
/**
* A StateMachine represents a deterministic finite automaton.
* It can perform matches over a sequence of values, similar to a regular expression.
*/
class StateMachine {
constructor(dfa) {
this.stateTable = dfa.stateTable;
this.accepting = dfa.accepting;
this.tags = dfa.tags;
}
/**
* Returns an iterable object that yields pattern matches over the input sequence.
* Matches are of the form [startIndex, endIndex, tags].
*/
match(str) {
var self = this;
return {
*[Symbol.iterator]() {
var state = INITIAL_STATE;
var startRun = null;
var lastAccepting = null;
var lastState = null;
for (var p = 0; p < str.length; p++) {
var c = str[p];
lastState = state;
state = self.stateTable[state][c];
if (state === FAIL_STATE) {
// yield the last match if any
if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
yield [startRun, lastAccepting, self.tags[lastState]];
} // reset the state as if we started over from the initial state
state = self.stateTable[INITIAL_STATE][c];
startRun = null;
} // start a run if not in the failure state
if (state !== FAIL_STATE && startRun == null) {
startRun = p;
} // if accepting, mark the potential match end
if (self.accepting[state]) {
lastAccepting = p;
} // reset the state to the initial state if we get into the failure state
if (state === FAIL_STATE) {
state = INITIAL_STATE;
}
} // yield the last match if any
if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
yield [startRun, lastAccepting, self.tags[state]];
}
}
};
}
/**
* For each match over the input sequence, action functions matching
* the tag definitions in the input pattern are called with the startIndex,
* endIndex, and sub-match sequence.
*/
apply(str, actions) {
for (var [start, end, tags] of this.match(str)) {
for (var tag of tags) {
if (typeof actions[tag] === 'function') {
actions[tag](start, end, str.slice(start, end + 1));
}
}
}
}
}
module.exports = StateMachine;
},{}],24:[function(require,module,exports){
'use strict';
// do not edit .js files directly - edit src/index.jst
module.exports = function equal(a, b) {
if (a === b) return true;
if (a && b && typeof a == 'object' && typeof b == 'object') {
if (a.constructor !== b.constructor) return false;
var length, i, keys;
if (Array.isArray(a)) {
length = a.length;
if (length != b.length) return false;
for (i = length; i-- !== 0;)
if (!equal(a[i], b[i])) return false;
return true;
}
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length) return false;
for (i = length; i-- !== 0;)
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
for (i = length; i-- !== 0;) {
var key = keys[i];
if (!equal(a[key], b[key])) return false;
}
return true;
}
// true if both NaN, false otherwise
return a!==a && b!==b;
};
},{}],25:[function(require,module,exports){
"use strict";
// DEFLATE is a complex format; to read this code, you should probably check the RFC first:
// https://tools.ietf.org/html/rfc1951
// You may also wish to take a look at the guide I made about this program:
// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad
exports.deflate = deflate;
exports.deflateSync = deflateSync;
exports.inflate = inflate;
exports.inflateSync = inflateSync;
exports.gzip = gzip;
exports.compress = gzip;
exports.gzipSync = gzipSync;
exports.compressSync = gzipSync;
exports.gunzip = gunzip;
exports.gunzipSync = gunzipSync;
exports.zlib = zlib;
exports.zlibSync = zlibSync;
exports.unzlib = unzlib;
exports.unzlibSync = unzlibSync;
exports.gzip = gzip;
exports.compress = gzip;
exports.decompress = decompress;
exports.decompressSync = decompressSync;
exports.strToU8 = strToU8;
exports.strFromU8 = strFromU8;
exports.zip = zip;
exports.zipSync = zipSync;
exports.unzip = unzip;
exports.unzipSync = unzipSync;
// Some of the following code is similar to that of UZIP.js:
// https://github.com/photopea/UZIP.js
// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.
// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint
// is better for memory in most engines (I *think*).
var node_worker_1 = require("./node-worker.cjs");
// aliases for shorter compressed code (most minifers don't do this)
var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
// fixed length extra bits
var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
// fixed distance extra bits
var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
// code length index map
var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
// get base, reverse index map from extra bits
var freb = function (eb, start) {
var b = new u16(31);
for (var i = 0; i < 31; ++i) {
b[i] = start += 1 << eb[i - 1];
}
// numbers here are at max 18 bits
var r = new i32(b[30]);
for (var i = 1; i < 30; ++i) {
for (var j = b[i]; j < b[i + 1]; ++j) {
r[j] = ((j - b[i]) << 5) | i;
}
}
return { b: b, r: r };
};
var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
// we can ignore the fact that the other numbers are wrong; they never happen anyway
fl[28] = 258, revfl[258] = 28;
var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r;
// map of value to reverse (assuming 16 bits)
var rev = new u16(32768);
for (var i = 0; i < 32768; ++i) {
// reverse table algorithm from SO
var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
}
// create huffman tree from u8 "map": index -> code length for code index
// mb (max bits) must be at most 15
// TODO: optimize/split up?
var hMap = (function (cd, mb, r) {
var s = cd.length;
// index
var i = 0;
// u16 "map": index -> # of codes with bit length = index
var l = new u16(mb);
// length of cd must be 288 (total # of codes)
for (; i < s; ++i) {
if (cd[i])
++l[cd[i] - 1];
}
// u16 "map": index -> minimum code for bit length = index
var le = new u16(mb);
for (i = 1; i < mb; ++i) {
le[i] = (le[i - 1] + l[i - 1]) << 1;
}
var co;
if (r) {
// u16 "map": index -> number of actual bits, symbol for code
co = new u16(1 << mb);
// bits to remove for reverser
var rvb = 15 - mb;
for (i = 0; i < s; ++i) {
// ignore 0 lengths
if (cd[i]) {
// num encoding both symbol and bits read
var sv = (i << 4) | cd[i];
// free bits
var r_1 = mb - cd[i];
// start value
var v = le[cd[i] - 1]++ << r_1;
// m is end value
for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
// every 16 bit value starting with the code yields the same result
co[rev[v] >> rvb] = sv;
}
}
}
}
else {
co = new u16(s);
for (i = 0; i < s; ++i) {
if (cd[i]) {
co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
}
}
}
return co;
});
// fixed length tree
var flt = new u8(288);
for (var i = 0; i < 144; ++i)
flt[i] = 8;
for (var i = 144; i < 256; ++i)
flt[i] = 9;
for (var i = 256; i < 280; ++i)
flt[i] = 7;
for (var i = 280; i < 288; ++i)
flt[i] = 8;
// fixed distance tree
var fdt = new u8(32);
for (var i = 0; i < 32; ++i)
fdt[i] = 5;
// fixed length map
var flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1);
// fixed distance map
var fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
// find max of array
var max = function (a) {
var m = a[0];
for (var i = 1; i < a.length; ++i) {
if (a[i] > m)
m = a[i];
}
return m;
};
// read d, starting at bit p and mask with m
var bits = function (d, p, m) {
var o = (p / 8) | 0;
return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;
};
// read d, starting at bit p continuing for at least 16 bits
var bits16 = function (d, p) {
var o = (p / 8) | 0;
return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));
};
// get end of byte
var shft = function (p) { return ((p + 7) / 8) | 0; };
// typed array slice - allows garbage collector to free original reference,
// while being more compatible than .slice
var slc = function (v, s, e) {
if (s == null || s < 0)
s = 0;
if (e == null || e > v.length)
e = v.length;
// can't use .constructor in case user-supplied
return new u8(v.subarray(s, e));
};
/**
* Codes for errors generated within this library
*/
exports.FlateErrorCode = {
UnexpectedEOF: 0,
InvalidBlockType: 1,
InvalidLengthLiteral: 2,
InvalidDistance: 3,
StreamFinished: 4,
NoStreamHandler: 5,
InvalidHeader: 6,
NoCallback: 7,
InvalidUTF8: 8,
ExtraFieldTooLong: 9,
InvalidDate: 10,
FilenameTooLong: 11,
StreamFinishing: 12,
InvalidZipData: 13,
UnknownCompressionMethod: 14
};
// error codes
var ec = [
'unexpected EOF',
'invalid block type',
'invalid length/literal',
'invalid distance',
'stream finished',
'no stream handler',
, // determined by compression function
'no callback',
'invalid UTF-8 data',
'extra field too long',
'date not in range 1980-2099',
'filename too long',
'stream finishing',
'invalid zip data'
// determined by unknown compression method
];
;
var err = function (ind, msg, nt) {
var e = new Error(msg || ec[ind]);
e.code = ind;
if (Error.captureStackTrace)
Error.captureStackTrace(e, err);
if (!nt)
throw e;
return e;
};
// expands raw DEFLATE data
var inflt = function (dat, st, buf, dict) {
// source length dict length
var sl = dat.length, dl = dict ? dict.length : 0;
if (!sl || st.f && !st.l)
return buf || new u8(0);
var noBuf = !buf;
// have to estimate size
var resize = noBuf || st.i != 2;
// no state
var noSt = st.i;
// Assumes roughly 33% compression ratio average
if (noBuf)
buf = new u8(sl * 3);
// ensure buffer can fit at least l elements
var cbuf = function (l) {
var bl = buf.length;
// need to increase size to fit
if (l > bl) {
// Double or set to necessary, whichever is greater
var nbuf = new u8(Math.max(bl * 2, l));
nbuf.set(buf);
buf = nbuf;
}
};
// last chunk bitpos bytes
var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
// total bits
var tbts = sl * 8;
do {
if (!lm) {
// BFINAL - this is only 1 when last chunk is next
final = bits(dat, pos, 1);
// type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
var type = bits(dat, pos + 1, 3);
pos += 3;
if (!type) {
// go to end of byte boundary
var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
if (t > sl) {
if (noSt)
err(0);
break;
}
// ensure size
if (resize)
cbuf(bt + l);
// Copy over uncompressed data
buf.set(dat.subarray(s, t), bt);
// Get new bitpos, update byte count
st.b = bt += l, st.p = pos = t * 8, st.f = final;
continue;
}
else if (type == 1)
lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
else if (type == 2) {
// literal lengths
var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
var tl = hLit + bits(dat, pos + 5, 31) + 1;
pos += 14;
// length+distance tree
var ldt = new u8(tl);
// code length tree
var clt = new u8(19);
for (var i = 0; i < hcLen; ++i) {
// use index map to get real code
clt[clim[i]] = bits(dat, pos + i * 3, 7);
}
pos += hcLen * 3;
// code lengths bits
var clb = max(clt), clbmsk = (1 << clb) - 1;
// code lengths map
var clm = hMap(clt, clb, 1);
for (var i = 0; i < tl;) {
var r = clm[bits(dat, pos, clbmsk)];
// bits read
pos += r & 15;
// symbol
var s = r >> 4;
// code length to copy
if (s < 16) {
ldt[i++] = s;
}
else {
// copy count
var c = 0, n = 0;
if (s == 16)
n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
else if (s == 17)
n = 3 + bits(dat, pos, 7), pos += 3;
else if (s == 18)
n = 11 + bits(dat, pos, 127), pos += 7;
while (n--)
ldt[i++] = c;
}
}
// length tree distance tree
var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
// max length bits
lbt = max(lt);
// max dist bits
dbt = max(dt);
lm = hMap(lt, lbt, 1);
dm = hMap(dt, dbt, 1);
}
else
err(1);
if (pos > tbts) {
if (noSt)
err(0);
break;
}
}
// Make sure the buffer can hold this + the largest possible addition
// Maximum chunk size (practically, theoretically infinite) is 2^17
if (resize)
cbuf(bt + 131072);
var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
var lpos = pos;
for (;; lpos = pos) {
// bits read, code
var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
pos += c & 15;
if (pos > tbts) {
if (noSt)
err(0);
break;
}
if (!c)
err(2);
if (sym < 256)
buf[bt++] = sym;
else if (sym == 256) {
lpos = pos, lm = null;
break;
}
else {
var add = sym - 254;
// no extra bits needed if less
if (sym > 264) {
// index
var i = sym - 257, b = fleb[i];
add = bits(dat, pos, (1 << b) - 1) + fl[i];
pos += b;
}
// dist
var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
if (!d)
err(3);
pos += d & 15;
var dt = fd[dsym];
if (dsym > 3) {
var b = fdeb[dsym];
dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
}
if (pos > tbts) {
if (noSt)
err(0);
break;
}
if (resize)
cbuf(bt + 131072);
var end = bt + add;
if (bt < dt) {
var shift = dl - dt, dend = Math.min(dt, end);
if (shift + bt < 0)
err(3);
for (; bt < dend; ++bt)
buf[bt] = dict[shift + bt];
}
for (; bt < end; ++bt)
buf[bt] = buf[bt - dt];
}
}
st.l = lm, st.p = lpos, st.b = bt, st.f = final;
if (lm)
final = 1, st.m = lbt, st.d = dm, st.n = dbt;
} while (!final);
// don't reallocate for streams or user buffers
return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
};
// starting at p, write the minimum number of bits that can hold v to d
var wbits = function (d, p, v) {
v <<= p & 7;
var o = (p / 8) | 0;
d[o] |= v;
d[o + 1] |= v >> 8;
};
// starting at p, write the minimum number of bits (>8) that can hold v to d
var wbits16 = function (d, p, v) {
v <<= p & 7;
var o = (p / 8) | 0;
d[o] |= v;
d[o + 1] |= v >> 8;
d[o + 2] |= v >> 16;
};
// creates code lengths from a frequency table
var hTree = function (d, mb) {
// Need extra info to make a tree
var t = [];
for (var i = 0; i < d.length; ++i) {
if (d[i])
t.push({ s: i, f: d[i] });
}
var s = t.length;
var t2 = t.slice();
if (!s)
return { t: et, l: 0 };
if (s == 1) {
var v = new u8(t[0].s + 1);
v[t[0].s] = 1;
return { t: v, l: 1 };
}
t.sort(function (a, b) { return a.f - b.f; });
// after i2 reaches last ind, will be stopped
// freq must be greater than largest possible number of symbols
t.push({ s: -1, f: 25001 });
var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
t[0] = { s: -1, f: l.f + r.f, l: l, r: r };
// efficient algorithm from UZIP.js
// i0 is lookbehind, i2 is lookahead - after processing two low-freq
// symbols that combined have high freq, will start processing i2 (high-freq,
// non-composite) symbols instead
// see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/
while (i1 != s - 1) {
l = t[t[i0].f < t[i2].f ? i0++ : i2++];
r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r };
}
var maxSym = t2[0].s;
for (var i = 1; i < s; ++i) {
if (t2[i].s > maxSym)
maxSym = t2[i].s;
}
// code lengths
var tr = new u16(maxSym + 1);
// max bits in tree
var mbt = ln(t[i1 - 1], tr, 0);
if (mbt > mb) {
// more algorithms from UZIP.js
// TODO: find out how this code works (debt)
// ind debt
var i = 0, dt = 0;
// left cost
var lft = mbt - mb, cst = 1 << lft;
t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; });
for (; i < s; ++i) {
var i2_1 = t2[i].s;
if (tr[i2_1] > mb) {
dt += cst - (1 << (mbt - tr[i2_1]));
tr[i2_1] = mb;
}
else
break;
}
dt >>= lft;
while (dt > 0) {
var i2_2 = t2[i].s;
if (tr[i2_2] < mb)
dt -= 1 << (mb - tr[i2_2]++ - 1);
else
++i;
}
for (; i >= 0 && dt; --i) {
var i2_3 = t2[i].s;
if (tr[i2_3] == mb) {
--tr[i2_3];
++dt;
}
}
mbt = mb;
}
return { t: new u8(tr), l: mbt };
};
// get the max length and assign length codes
var ln = function (n, l, d) {
return n.s == -1
? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1))
: (l[n.s] = d);
};
// length codes generation
var lc = function (c) {
var s = c.length;
// Note that the semicolon was intentional
while (s && !c[--s])
;
var cl = new u16(++s);
// ind num streak
var cli = 0, cln = c[0], cls = 1;
var w = function (v) { cl[cli++] = v; };
for (var i = 1; i <= s; ++i) {
if (c[i] == cln && i != s)
++cls;
else {
if (!cln && cls > 2) {
for (; cls > 138; cls -= 138)
w(32754);
if (cls > 2) {
w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305);
cls = 0;
}
}
else if (cls > 3) {
w(cln), --cls;
for (; cls > 6; cls -= 6)
w(8304);
if (cls > 2)
w(((cls - 3) << 5) | 8208), cls = 0;
}
while (cls--)
w(cln);
cls = 1;
cln = c[i];
}
}
return { c: cl.subarray(0, cli), n: s };
};
// calculate the length of output from tree, code lengths
var clen = function (cf, cl) {
var l = 0;
for (var i = 0; i < cl.length; ++i)
l += cf[i] * cl[i];
return l;
};
// writes a fixed block
// returns the new bit pos
var wfblk = function (out, pos, dat) {
// no need to write 00 as type: TypedArray defaults to 0
var s = dat.length;
var o = shft(pos + 2);
out[o] = s & 255;
out[o + 1] = s >> 8;
out[o + 2] = out[o] ^ 255;
out[o + 3] = out[o + 1] ^ 255;
for (var i = 0; i < s; ++i)
out[o + i + 4] = dat[i];
return (o + 4 + s) * 8;
};
// writes a block
var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
wbits(out, p++, final);
++lf[256];
var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l;
var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l;
var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
var lcfreq = new u16(19);
for (var i = 0; i < lclt.length; ++i)
++lcfreq[lclt[i] & 31];
for (var i = 0; i < lcdt.length; ++i)
++lcfreq[lcdt[i] & 31];
var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
var nlcc = 19;
for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
;
var flen = (bl + 5) << 3;
var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
if (bs >= 0 && flen <= ftlen && flen <= dtlen)
return wfblk(out, p, dat.subarray(bs, bs + bl));
var lm, ll, dm, dl;
wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
if (dtlen < ftlen) {
lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
var llm = hMap(lct, mlcb, 0);
wbits(out, p, nlc - 257);
wbits(out, p + 5, ndc - 1);
wbits(out, p + 10, nlcc - 4);
p += 14;
for (var i = 0; i < nlcc; ++i)
wbits(out, p + 3 * i, lct[clim[i]]);
p += 3 * nlcc;
var lcts = [lclt, lcdt];
for (var it = 0; it < 2; ++it) {
var clct = lcts[it];
for (var i = 0; i < clct.length; ++i) {
var len = clct[i] & 31;
wbits(out, p, llm[len]), p += lct[len];
if (len > 15)
wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12;
}
}
}
else {
lm = flm, ll = flt, dm = fdm, dl = fdt;
}
for (var i = 0; i < li; ++i) {
var sym = syms[i];
if (sym > 255) {
var len = (sym >> 18) & 31;
wbits16(out, p, lm[len + 257]), p += ll[len + 257];
if (len > 7)
wbits(out, p, (sym >> 23) & 31), p += fleb[len];
var dst = sym & 31;
wbits16(out, p, dm[dst]), p += dl[dst];
if (dst > 3)
wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst];
}
else {
wbits16(out, p, lm[sym]), p += ll[sym];
}
}
wbits16(out, p, lm[256]);
return p + ll[256];
};
// deflate options (nice << 13) | chain
var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
// empty
var et = /*#__PURE__*/ new u8(0);
// compresses data into a raw DEFLATE buffer
var dflt = function (dat, lvl, plvl, pre, post, st) {
var s = st.z || dat.length;
var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
// writing to this writes to the output buffer
var w = o.subarray(pre, o.length - post);
var lst = st.l;
var pos = (st.r || 0) & 7;
if (lvl) {
if (pos)
w[0] = st.r >> 3;
var opt = deo[lvl - 1];
var n = opt >> 13, c = opt & 8191;
var msk_1 = (1 << plvl) - 1;
// prev 2-byte val map curr 2-byte val map
var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };
// 24576 is an arbitrary number of maximum symbols per block
// 424 buffer for last block
var syms = new i32(25000);
// length/literal freq distance freq
var lf = new u16(288), df = new u16(32);
// l/lcnt exbits index l/lind waitdx blkpos
var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
for (; i + 2 < s; ++i) {
// hash value
var hv = hsh(i);
// index mod 32768 previous index mod
var imod = i & 32767, pimod = head[hv];
prev[imod] = pimod;
head[hv] = imod;
// We always should modify head and prev, but only add symbols if
// this data is not yet processed ("wait" for wait index)
if (wi <= i) {
// bytes remaining
var rem = s - i;
if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
li = lc_1 = eb = 0, bs = i;
for (var j = 0; j < 286; ++j)
lf[j] = 0;
for (var j = 0; j < 30; ++j)
df[j] = 0;
}
// len dist chain
var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
if (rem > 2 && hv == hsh(i - dif)) {
var maxn = Math.min(n, rem) - 1;
var maxd = Math.min(32767, i);
// max possible length
// not capped at dif because decompressors implement "rolling" index population
var ml = Math.min(258, rem);
while (dif <= maxd && --ch_1 && imod != pimod) {
if (dat[i + l] == dat[i + l - dif]) {
var nl = 0;
for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
;
if (nl > l) {
l = nl, d = dif;
// break out early when we reach "nice" (we are satisfied enough)
if (nl > maxn)
break;
// now, find the rarest 2-byte sequence within this
// length of literals and search for that instead.
// Much faster than just using the start
var mmd = Math.min(dif, nl - 2);
var md = 0;
for (var j = 0; j < mmd; ++j) {
var ti = i - dif + j & 32767;
var pti = prev[ti];
var cd = ti - pti & 32767;
if (cd > md)
md = cd, pimod = ti;
}
}
}
// check the previous match
imod = pimod, pimod = prev[imod];
dif += imod - pimod & 32767;
}
}
// d will be nonzero only when a match was found
if (d) {
// store both dist and len data in one int32
// Make sure this is recognized as a len/dist with 28th bit (2^28)
syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];
var lin = revfl[l] & 31, din = revfd[d] & 31;
eb += fleb[lin] + fdeb[din];
++lf[257 + lin];
++df[din];
wi = i + l;
++lc_1;
}
else {
syms[li++] = dat[i];
++lf[dat[i]];
}
}
}
for (i = Math.max(i, wi); i < s; ++i) {
syms[li++] = dat[i];
++lf[dat[i]];
}
pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
if (!lst) {
st.r = (pos & 7) | w[(pos / 8) | 0] << 3;
// shft(pos) now 1 less if pos & 7 != 0
pos -= 7;
st.h = head, st.p = prev, st.i = i, st.w = wi;
}
}
else {
for (var i = st.w || 0; i < s + lst; i += 65535) {
// end
var e = i + 65535;
if (e >= s) {
// write final block
w[(pos / 8) | 0] = lst;
e = s;
}
pos = wfblk(w, pos + 1, dat.subarray(i, e));
}
st.i = s;
}
return slc(o, 0, pre + shft(pos) + post);
};
// CRC32 table
var crct = /*#__PURE__*/ (function () {
var t = new Int32Array(256);
for (var i = 0; i < 256; ++i) {
var c = i, k = 9;
while (--k)
c = ((c & 1) && -306674912) ^ (c >>> 1);
t[i] = c;
}
return t;
})();
// CRC32
var crc = function () {
var c = -1;
return {
p: function (d) {
// closures have awful performance
var cr = c;
for (var i = 0; i < d.length; ++i)
cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8);
c = cr;
},
d: function () { return ~c; }
};
};
// Adler32
var adler = function () {
var a = 1, b = 0;
return {
p: function (d) {
// closures have awful performance
var n = a, m = b;
var l = d.length | 0;
for (var i = 0; i != l;) {
var e = Math.min(i + 2655, l);
for (; i < e; ++i)
m += n += d[i];
n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);
}
a = n, b = m;
},
d: function () {
a %= 65521, b %= 65521;
return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8);
}
};
};
;
// deflate with opts
var dopt = function (dat, opt, pre, post, st) {
if (!st) {
st = { l: 1 };
if (opt.dictionary) {
var dict = opt.dictionary.subarray(-32768);
var newDat = new u8(dict.length + dat.length);
newDat.set(dict);
newDat.set(dat, dict.length);
dat = newDat;
st.w = dict.length;
}
}
return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st);
};
// Walmart object spread
var mrg = function (a, b) {
var o = {};
for (var k in a)
o[k] = a[k];
for (var k in b)
o[k] = b[k];
return o;
};
// worker clone
// This is possibly the craziest part of the entire codebase, despite how simple it may seem.
// The only parameter to this function is a closure that returns an array of variables outside of the function scope.
// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization.
// We will return an object mapping of true variable name to value (basically, the current scope as a JS object).
// The reason we can't just use the original variable names is minifiers mangling the toplevel scope.
// This took me three weeks to figure out how to do.
var wcln = function (fn, fnStr, td) {
var dt = fn();
var st = fn.toString();
var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\s+/g, '').split(',');
for (var i = 0; i < dt.length; ++i) {
var v = dt[i], k = ks[i];
if (typeof v == 'function') {
fnStr += ';' + k + '=';
var st_1 = v.toString();
if (v.prototype) {
// for global objects
if (st_1.indexOf('[native code]') != -1) {
var spInd = st_1.indexOf(' ', 8) + 1;
fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd));
}
else {
fnStr += st_1;
for (var t in v.prototype)
fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString();
}
}
else
fnStr += st_1;
}
else
td[k] = v;
}
return fnStr;
};
var ch = [];
// clone bufs
var cbfs = function (v) {
var tl = [];
for (var k in v) {
if (v[k].buffer) {
tl.push((v[k] = new v[k].constructor(v[k])).buffer);
}
}
return tl;
};
// use a worker to execute code
var wrkr = function (fns, init, id, cb) {
if (!ch[id]) {
var fnStr = '', td_1 = {}, m = fns.length - 1;
for (var i = 0; i < m; ++i)
fnStr = wcln(fns[i], fnStr, td_1);
ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };
}
var td = mrg({}, ch[id].e);
return (0, node_worker_1.default)(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);
};
// base async inflate fn
var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; };
var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };
// gzip extra
var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; };
// gunzip extra
var guze = function () { return [gzs, gzl]; };
// zlib extra
var zle = function () { return [zlh, wbytes, adler]; };
// unzlib extra
var zule = function () { return [zls]; };
// post buf
var pbf = function (msg) { return postMessage(msg, [msg.buffer]); };
// get opts
var gopt = function (o) { return o && {
out: o.size && new u8(o.size),
dictionary: o.dictionary
}; };
// async helper
var cbify = function (dat, opts, fns, init, id, cb) {
var w = wrkr(fns, init, id, function (err, dat) {
w.terminate();
cb(err, dat);
});
w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);
return function () { w.terminate(); };
};
// auto stream
var astrm = function (strm) {
strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); };
return function (ev) {
if (ev.data[0]) {
strm.push(ev.data[0], ev.data[1]);
postMessage([ev.data[0].length]);
}
else
strm.flush(ev.data[1]);
};
};
// async stream attach
var astrmify = function (fns, strm, opts, init, id, flush, ext) {
var t;
var w = wrkr(fns, init, id, function (err, dat) {
if (err)
w.terminate(), strm.ondata.call(strm, err);
else if (!Array.isArray(dat))
ext(dat);
else if (dat.length == 1) {
strm.queuedSize -= dat[0];
if (strm.ondrain)
strm.ondrain(dat[0]);
}
else {
if (dat[1])
w.terminate();
strm.ondata.call(strm, err, dat[0], dat[1]);
}
});
w.postMessage(opts);
strm.queuedSize = 0;
strm.push = function (d, f) {
if (!strm.ondata)
err(5);
if (t)
strm.ondata(err(4, 0, 1), null, !!f);
strm.queuedSize += d.length;
// can fail for cross-realm Uint8Array, but ok - only a small performance penalty
w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []);
};
strm.terminate = function () { w.terminate(); };
if (flush) {
strm.flush = function (sync) { w.postMessage([0, sync]); };
}
};
// read 2 bytes
var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };
// read 4 bytes
var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };
// read 8 bytes
var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };
// write bytes
var wbytes = function (d, b, v) {
for (; v; ++b)
d[b] = v, v >>>= 8;
};
// gzip header
var gzh = function (c, o) {
var fn = o.filename;
c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix
if (o.mtime != 0)
wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000));
if (fn) {
c[3] = 8;
for (var i = 0; i <= fn.length; ++i)
c[i + 10] = fn.charCodeAt(i);
}
};
// gzip footer: -8 to -4 = CRC, -4 to -0 is length
// gzip start
var gzs = function (d) {
if (d[0] != 31 || d[1] != 139 || d[2] != 8)
err(6, 'invalid gzip data');
var flg = d[3];
var st = 10;
if (flg & 4)
st += (d[10] | d[11] << 8) + 2;
for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
;
return st + (flg & 2);
};
// gzip length
var gzl = function (d) {
var l = d.length;
return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
};
// gzip header length
var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); };
// zlib header
var zlh = function (c, o) {
var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32);
c[1] |= 31 - ((c[0] << 8) | c[1]) % 31;
if (o.dictionary) {
var h = adler();
h.p(o.dictionary);
wbytes(c, 2, h.d());
}
};
// zlib start
var zls = function (d, dict) {
if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31))
err(6, 'invalid zlib data');
if ((d[1] >> 5 & 1) == +!dict)
err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary');
return (d[1] >> 3 & 4) + 2;
};
function StrmOpt(opts, cb) {
if (typeof opts == 'function')
cb = opts, opts = {};
this.ondata = cb;
return opts;
}
/**
* Streaming DEFLATE compression
*/
var Deflate = /*#__PURE__*/ (function () {
function Deflate(opts, cb) {
if (typeof opts == 'function')
cb = opts, opts = {};
this.ondata = cb;
this.o = opts || {};
this.s = { l: 0, i: 32768, w: 32768, z: 32768 };
// Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev
// 98304 = 32768 (lookback) + 65536 (common chunk size)
this.b = new u8(98304);
if (this.o.dictionary) {
var dict = this.o.dictionary.subarray(-32768);
this.b.set(dict, 32768 - dict.length);
this.s.i = 32768 - dict.length;
}
}
Deflate.prototype.p = function (c, f) {
this.ondata(dopt(c, this.o, 0, 0, this.s), f);
};
/**
* Pushes a chunk to be deflated
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
Deflate.prototype.push = function (chunk, final) {
if (!this.ondata)
err(5);
if (this.s.l)
err(4);
var endLen = chunk.length + this.s.z;
if (endLen > this.b.length) {
if (endLen > 2 * this.b.length - 32768) {
var newBuf = new u8(endLen & -32768);
newBuf.set(this.b.subarray(0, this.s.z));
this.b = newBuf;
}
var split = this.b.length - this.s.z;
this.b.set(chunk.subarray(0, split), this.s.z);
this.s.z = this.b.length;
this.p(this.b, false);
this.b.set(this.b.subarray(-32768));
this.b.set(chunk.subarray(split), 32768);
this.s.z = chunk.length - split + 32768;
this.s.i = 32766, this.s.w = 32768;
}
else {
this.b.set(chunk, this.s.z);
this.s.z += chunk.length;
}
this.s.l = final & 1;
if (this.s.z > this.s.w + 8191 || final) {
this.p(this.b, final || false);
this.s.w = this.s.i, this.s.i -= 2;
}
if (final) {
// cleanup unneeded buffers/state to reduce memory usage
this.s = this.o = {};
this.b = et;
}
};
/**
* Flushes buffered uncompressed data. Useful to immediately retrieve the
* deflated output for small inputs.
* @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
* extra bytes, but guarantees all pushed data is immediately
* decompressible. A separate DEFLATE stream may be concatenated
* with the current output after a sync flush.
*/
Deflate.prototype.flush = function (sync) {
if (!this.ondata)
err(5);
if (this.s.l)
err(4);
this.p(this.b, false);
this.s.w = this.s.i, this.s.i -= 2;
// could technically skip writing the type-0 block for (this.s.r & 7) == 0,
// but the deterministic trailer (00 00 FF FF) is useful in some situations
if (sync) {
var c = new u8(6);
c[0] = this.s.r >> 3;
// write empty, non-final type-0 block
var ep = wfblk(c, this.s.r, et);
this.s.r = 0;
this.ondata(c.subarray(0, ep >> 3), false);
}
};
return Deflate;
}());
exports.Deflate = Deflate;
/**
* Asynchronous streaming DEFLATE compression
*/
var AsyncDeflate = /*#__PURE__*/ (function () {
function AsyncDeflate(opts, cb) {
astrmify([
bDflt,
function () { return [astrm, Deflate]; }
], this, StrmOpt.call(this, opts, cb), function (ev) {
var strm = new Deflate(ev.data);
onmessage = astrm(strm);
}, 6, 1);
}
return AsyncDeflate;
}());
exports.AsyncDeflate = AsyncDeflate;
function deflate(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
return cbify(data, opts, [
bDflt,
], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb);
}
/**
* Compresses data with DEFLATE without any wrapper
* @param data The data to compress
* @param opts The compression options
* @returns The deflated version of the data
*/
function deflateSync(data, opts) {
return dopt(data, opts || {}, 0, 0);
}
/**
* Streaming DEFLATE decompression
*/
var Inflate = /*#__PURE__*/ (function () {
function Inflate(opts, cb) {
// no StrmOpt here to avoid adding to workerizer
if (typeof opts == 'function')
cb = opts, opts = {};
this.ondata = cb;
var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
this.s = { i: 0, b: dict ? dict.length : 0 };
this.o = new u8(32768);
this.p = new u8(0);
if (dict)
this.o.set(dict);
}
Inflate.prototype.e = function (c) {
if (!this.ondata)
err(5);
if (this.d)
err(4);
if (!this.p.length)
this.p = c;
else if (c.length) {
var n = new u8(this.p.length + c.length);
n.set(this.p), n.set(c, this.p.length), this.p = n;
}
};
Inflate.prototype.c = function (final) {
this.s.i = +(this.d = final || false);
var bts = this.s.b;
var dt = inflt(this.p, this.s, this.o);
this.ondata(slc(dt, bts, this.s.b), this.d);
this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7;
};
/**
* Pushes a chunk to be inflated
* @param chunk The chunk to push
* @param final Whether this is the final chunk
*/
Inflate.prototype.push = function (chunk, final) {
this.e(chunk), this.c(final);
};
return Inflate;
}());
exports.Inflate = Inflate;
/**
* Asynchronous streaming DEFLATE decompression
*/
var AsyncInflate = /*#__PURE__*/ (function () {
function AsyncInflate(opts, cb) {
astrmify([
bInflt,
function () { return [astrm, Inflate]; }
], this, StrmOpt.call(this, opts, cb), function (ev) {
var strm = new Inflate(ev.data);
onmessage = astrm(strm);
}, 7, 0);
}
return AsyncInflate;
}());
exports.AsyncInflate = AsyncInflate;
function inflate(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
return cbify(data, opts, [
bInflt
], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb);
}
function inflateSync(data, opts) {
return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
}
// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize.
/**
* Streaming GZIP compression
*/
var Gzip = /*#__PURE__*/ (function () {
function Gzip(opts, cb) {
this.c = crc();
this.l = 0;
this.v = 1;
Deflate.call(this, opts, cb);
}
/**
* Pushes a chunk to be GZIPped
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
Gzip.prototype.push = function (chunk, final) {
this.c.p(chunk);
this.l += chunk.length;
Deflate.prototype.push.call(this, chunk, final);
};
Gzip.prototype.p = function (c, f) {
var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s);
if (this.v)
gzh(raw, this.o), this.v = 0;
if (f)
wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l);
this.ondata(raw, f);
};
/**
* Flushes buffered uncompressed data. Useful to immediately retrieve the
* GZIPped output for small inputs.
* @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
* extra bytes, but guarantees all pushed data is immediately
* decompressible.
*/
Gzip.prototype.flush = function (sync) {
Deflate.prototype.flush.call(this, sync);
};
return Gzip;
}());
exports.Gzip = Gzip;
exports.Compress = Gzip;
/**
* Asynchronous streaming GZIP compression
*/
var AsyncGzip = /*#__PURE__*/ (function () {
function AsyncGzip(opts, cb) {
astrmify([
bDflt,
gze,
function () { return [astrm, Deflate, Gzip]; }
], this, StrmOpt.call(this, opts, cb), function (ev) {
var strm = new Gzip(ev.data);
onmessage = astrm(strm);
}, 8, 1);
}
return AsyncGzip;
}());
exports.AsyncGzip = AsyncGzip;
exports.AsyncCompress = AsyncGzip;
function gzip(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
return cbify(data, opts, [
bDflt,
gze,
function () { return [gzipSync]; }
], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb);
}
/**
* Compresses data with GZIP
* @param data The data to compress
* @param opts The compression options
* @returns The gzipped version of the data
*/
function gzipSync(data, opts) {
if (!opts)
opts = {};
var c = crc(), l = data.length;
c.p(data);
var d = dopt(data, opts, gzhl(opts), 8), s = d.length;
return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;
}
/**
* Streaming single or multi-member GZIP decompression
*/
var Gunzip = /*#__PURE__*/ (function () {
function Gunzip(opts, cb) {
this.v = 1;
this.r = 0;
Inflate.call(this, opts, cb);
}
/**
* Pushes a chunk to be GUNZIPped
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
Gunzip.prototype.push = function (chunk, final) {
Inflate.prototype.e.call(this, chunk);
this.r += chunk.length;
if (this.v) {
var p = this.p.subarray(this.v - 1);
var s = p.length > 3 ? gzs(p) : 4;
if (s > p.length) {
if (!final)
return;
}
else if (this.v > 1 && this.onmember) {
this.onmember(this.r - p.length);
}
this.p = p.subarray(s), this.v = 0;
}
// necessary to prevent TS from using the closure value
// This allows for workerization to function correctly
Inflate.prototype.c.call(this, 0);
// process concatenated GZIP
if (this.s.f && !this.s.l) {
this.v = shft(this.s.p) + 9;
this.s = { i: 0 };
this.o = new u8(0);
this.push(new u8(0), final);
}
else if (final) {
Inflate.prototype.c.call(this, final);
}
};
return Gunzip;
}());
exports.Gunzip = Gunzip;
/**
* Asynchronous streaming single or multi-member GZIP decompression
*/
var AsyncGunzip = /*#__PURE__*/ (function () {
function AsyncGunzip(opts, cb) {
var _this = this;
astrmify([
bInflt,
guze,
function () { return [astrm, Inflate, Gunzip]; }
], this, StrmOpt.call(this, opts, cb), function (ev) {
var strm = new Gunzip(ev.data);
strm.onmember = function (offset) { return postMessage(offset); };
onmessage = astrm(strm);
}, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); });
}
return AsyncGunzip;
}());
exports.AsyncGunzip = AsyncGunzip;
function gunzip(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
return cbify(data, opts, [
bInflt,
guze,
function () { return [gunzipSync]; }
], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb);
}
function gunzipSync(data, opts) {
var st = gzs(data);
if (st + 8 > data.length)
err(6, 'invalid gzip data');
return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
}
/**
* Streaming Zlib compression
*/
var Zlib = /*#__PURE__*/ (function () {
function Zlib(opts, cb) {
this.c = adler();
this.v = 1;
Deflate.call(this, opts, cb);
}
/**
* Pushes a chunk to be zlibbed
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
Zlib.prototype.push = function (chunk, final) {
this.c.p(chunk);
Deflate.prototype.push.call(this, chunk, final);
};
Zlib.prototype.p = function (c, f) {
var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s);
if (this.v)
zlh(raw, this.o), this.v = 0;
if (f)
wbytes(raw, raw.length - 4, this.c.d());
this.ondata(raw, f);
};
/**
* Flushes buffered uncompressed data. Useful to immediately retrieve the
* zlibbed output for small inputs.
* @param sync Whether to flush to a byte boundary. A sync flush takes 4-5
* extra bytes, but guarantees all pushed data is immediately
* decompressible.
*/
Zlib.prototype.flush = function (sync) {
Deflate.prototype.flush.call(this, sync);
};
return Zlib;
}());
exports.Zlib = Zlib;
/**
* Asynchronous streaming Zlib compression
*/
var AsyncZlib = /*#__PURE__*/ (function () {
function AsyncZlib(opts, cb) {
astrmify([
bDflt,
zle,
function () { return [astrm, Deflate, Zlib]; }
], this, StrmOpt.call(this, opts, cb), function (ev) {
var strm = new Zlib(ev.data);
onmessage = astrm(strm);
}, 10, 1);
}
return AsyncZlib;
}());
exports.AsyncZlib = AsyncZlib;
function zlib(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
return cbify(data, opts, [
bDflt,
zle,
function () { return [zlibSync]; }
], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb);
}
/**
* Compress data with Zlib
* @param data The data to compress
* @param opts The compression options
* @returns The zlib-compressed version of the data
*/
function zlibSync(data, opts) {
if (!opts)
opts = {};
var a = adler();
a.p(data);
var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4);
return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;
}
/**
* Streaming Zlib decompression
*/
var Unzlib = /*#__PURE__*/ (function () {
function Unzlib(opts, cb) {
Inflate.call(this, opts, cb);
this.v = opts && opts.dictionary ? 2 : 1;
}
/**
* Pushes a chunk to be unzlibbed
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
Unzlib.prototype.push = function (chunk, final) {
Inflate.prototype.e.call(this, chunk);
if (this.v) {
if (this.p.length < 6 && !final)
return;
this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0;
}
if (final) {
if (this.p.length < 4)
err(6, 'invalid zlib data');
this.p = this.p.subarray(0, -4);
}
// necessary to prevent TS from using the closure value
// This allows for workerization to function correctly
Inflate.prototype.c.call(this, final);
};
return Unzlib;
}());
exports.Unzlib = Unzlib;
/**
* Asynchronous streaming Zlib decompression
*/
var AsyncUnzlib = /*#__PURE__*/ (function () {
function AsyncUnzlib(opts, cb) {
astrmify([
bInflt,
zule,
function () { return [astrm, Inflate, Unzlib]; }
], this, StrmOpt.call(this, opts, cb), function (ev) {
var strm = new Unzlib(ev.data);
onmessage = astrm(strm);
}, 11, 0);
}
return AsyncUnzlib;
}());
exports.AsyncUnzlib = AsyncUnzlib;
function unzlib(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
return cbify(data, opts, [
bInflt,
zule,
function () { return [unzlibSync]; }
], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb);
}
function unzlibSync(data, opts) {
return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary);
}
/**
* Streaming GZIP, Zlib, or raw DEFLATE decompression
*/
var Decompress = /*#__PURE__*/ (function () {
function Decompress(opts, cb) {
this.o = StrmOpt.call(this, opts, cb) || {};
this.G = Gunzip;
this.I = Inflate;
this.Z = Unzlib;
}
// init substream
// overriden by AsyncDecompress
Decompress.prototype.i = function () {
var _this = this;
this.s.ondata = function (dat, final) {
_this.ondata(dat, final);
};
};
/**
* Pushes a chunk to be decompressed
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
Decompress.prototype.push = function (chunk, final) {
if (!this.ondata)
err(5);
if (!this.s) {
if (this.p && this.p.length) {
var n = new u8(this.p.length + chunk.length);
n.set(this.p), n.set(chunk, this.p.length);
}
else
this.p = chunk;
if (this.p.length > 2) {
this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8)
? new this.G(this.o)
: ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31))
? new this.I(this.o)
: new this.Z(this.o);
this.i();
this.s.push(this.p, final);
this.p = null;
}
}
else
this.s.push(chunk, final);
};
return Decompress;
}());
exports.Decompress = Decompress;
/**
* Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression
*/
var AsyncDecompress = /*#__PURE__*/ (function () {
function AsyncDecompress(opts, cb) {
Decompress.call(this, opts, cb);
this.queuedSize = 0;
this.G = AsyncGunzip;
this.I = AsyncInflate;
this.Z = AsyncUnzlib;
}
AsyncDecompress.prototype.i = function () {
var _this = this;
this.s.ondata = function (err, dat, final) {
_this.ondata(err, dat, final);
};
this.s.ondrain = function (size) {
_this.queuedSize -= size;
if (_this.ondrain)
_this.ondrain(size);
};
};
/**
* Pushes a chunk to be decompressed
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
AsyncDecompress.prototype.push = function (chunk, final) {
this.queuedSize += chunk.length;
Decompress.prototype.push.call(this, chunk, final);
};
return AsyncDecompress;
}());
exports.AsyncDecompress = AsyncDecompress;
function decompress(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
return (data[0] == 31 && data[1] == 139 && data[2] == 8)
? gunzip(data, opts, cb)
: ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))
? inflate(data, opts, cb)
: unzlib(data, opts, cb);
}
/**
* Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format
* @param data The data to decompress
* @param opts The decompression options
* @returns The decompressed version of the data
*/
function decompressSync(data, opts) {
return (data[0] == 31 && data[1] == 139 && data[2] == 8)
? gunzipSync(data, opts)
: ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))
? inflateSync(data, opts)
: unzlibSync(data, opts);
}
// flatten a directory structure
var fltn = function (d, p, t, o) {
for (var k in d) {
var val = d[k], n = p + k, op = o;
if (Array.isArray(val))
op = mrg(o, val[1]), val = val[0];
if (ArrayBuffer.isView(val))
t[n] = [val, op];
else {
t[n += '/'] = [new u8(0), op];
fltn(val, n, t, o);
}
}
};
// text encoder
var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder();
// text decoder
var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();
// text decoder stream
var tds = 0;
try {
td.decode(et, { stream: true });
tds = 1;
}
catch (e) { }
// decode UTF8
var dutf8 = function (d) {
for (var r = '', i = 0;;) {
var c = d[i++];
var eb = (c > 127) + (c > 223) + (c > 239);
if (i + eb > d.length)
return { s: r, r: slc(d, i - 1) };
if (!eb)
r += String.fromCharCode(c);
else if (eb == 3) {
c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,
r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));
}
else if (eb & 1)
r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));
else
r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));
}
};
/**
* Streaming UTF-8 decoding
*/
var DecodeUTF8 = /*#__PURE__*/ (function () {
/**
* Creates a UTF-8 decoding stream
* @param cb The callback to call whenever data is decoded
*/
function DecodeUTF8(cb) {
this.ondata = cb;
if (tds)
this.t = new TextDecoder();
else
this.p = et;
}
/**
* Pushes a chunk to be decoded from UTF-8 binary
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
DecodeUTF8.prototype.push = function (chunk, final) {
if (!this.ondata)
err(5);
final = !!final;
if (this.t) {
this.ondata(this.t.decode(chunk, { stream: true }), final);
if (final) {
if (this.t.decode().length)
err(8);
this.t = null;
}
return;
}
if (!this.p)
err(4);
var dat = new u8(this.p.length + chunk.length);
dat.set(this.p);
dat.set(chunk, this.p.length);
var _a = dutf8(dat), s = _a.s, r = _a.r;
if (final) {
if (r.length)
err(8);
this.p = null;
}
else
this.p = r;
this.ondata(s, final);
};
return DecodeUTF8;
}());
exports.DecodeUTF8 = DecodeUTF8;
/**
* Streaming UTF-8 encoding
*/
var EncodeUTF8 = /*#__PURE__*/ (function () {
/**
* Creates a UTF-8 decoding stream
* @param cb The callback to call whenever data is encoded
*/
function EncodeUTF8(cb) {
this.ondata = cb;
}
/**
* Pushes a chunk to be encoded to UTF-8
* @param chunk The string data to push
* @param final Whether this is the last chunk
*/
EncodeUTF8.prototype.push = function (chunk, final) {
if (!this.ondata)
err(5);
if (this.d)
err(4);
this.ondata(strToU8(chunk), this.d = final || false);
};
return EncodeUTF8;
}());
exports.EncodeUTF8 = EncodeUTF8;
/**
* Converts a string into a Uint8Array for use with compression/decompression methods
* @param str The string to encode
* @param latin1 Whether or not to interpret the data as Latin-1. This should
* not need to be true unless decoding a binary string.
* @returns The string encoded in UTF-8/Latin-1 binary
*/
function strToU8(str, latin1) {
if (latin1) {
var ar_1 = new u8(str.length);
for (var i = 0; i < str.length; ++i)
ar_1[i] = str.charCodeAt(i);
return ar_1;
}
if (te)
return te.encode(str);
var l = str.length;
var ar = new u8(str.length + (str.length >> 1));
var ai = 0;
var w = function (v) { ar[ai++] = v; };
for (var i = 0; i < l; ++i) {
if (ai + 5 > ar.length) {
var n = new u8(ai + 8 + ((l - i) << 1));
n.set(ar);
ar = n;
}
var c = str.charCodeAt(i);
if (c < 128 || latin1)
w(c);
else if (c < 2048)
w(192 | (c >> 6)), w(128 | (c & 63));
else if (c > 55295 && c < 57344)
c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),
w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));
else
w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));
}
return slc(ar, 0, ai);
}
/**
* Converts a Uint8Array to a string
* @param dat The data to decode to string
* @param latin1 Whether or not to interpret the data as Latin-1. This should
* not need to be true unless encoding to binary string.
* @returns The original UTF-8/Latin-1 string
*/
function strFromU8(dat, latin1) {
if (latin1) {
var r = '';
for (var i = 0; i < dat.length; i += 16384)
r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
return r;
}
else if (td) {
return td.decode(dat);
}
else {
var _a = dutf8(dat), s = _a.s, r = _a.r;
if (r.length)
err(8);
return s;
}
}
;
// deflate bit flag
var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; };
// skip local zip header
var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };
// read zip header
var zh = function (d, b, z) {
var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl;
var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2];
return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
};
// read zip64 header sizes
var z64hs = function (d, b, l, z, sc, su, off) {
var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l;
var nf = nsc + nsu + noff;
if (z && nf) {
for (; b + 4 < e; b += 4 + b2(d, b + 2)) {
if (b2(d, b) == 1) {
return [
nsc ? b8(d, b + 4 + 8 * nsu) : sc,
nsu ? b8(d, b + 4) : su,
noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off,
1
];
}
}
// z == 2 for unknown whether or not zip64
if (z < 2)
err(13);
}
return [sc, su, off, 0];
};
// extra field length
var exfl = function (ex) {
var le = 0;
if (ex) {
for (var k in ex) {
var l = ex[k].length;
if (l > 65535)
err(9);
le += l + 4;
}
}
return le;
};
// write zip header
var wzh = function (d, b, f, fn, u, c, ce, co) {
var fl = fn.length, ex = f.extra, col = co && co.length;
var exl = exfl(ex);
wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4;
if (ce != null)
d[b++] = 20, d[b++] = f.os;
d[b] = 20, b += 2; // spec compliance? what's that?
d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8;
d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
if (y < 0 || y > 119)
err(10);
wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4;
if (c != -1) {
wbytes(d, b, f.crc);
wbytes(d, b + 4, c < 0 ? -c - 2 : c);
wbytes(d, b + 8, f.size);
}
wbytes(d, b + 12, fl);
wbytes(d, b + 14, exl), b += 16;
if (ce != null) {
wbytes(d, b, col);
wbytes(d, b + 6, f.attrs);
wbytes(d, b + 10, ce), b += 14;
}
d.set(fn, b);
b += fl;
if (exl) {
for (var k in ex) {
var exf = ex[k], l = exf.length;
wbytes(d, b, +k);
wbytes(d, b + 2, l);
d.set(exf, b + 4), b += 4 + l;
}
}
if (col)
d.set(co, b), b += col;
return b;
};
// write zip footer (end of central directory)
var wzf = function (o, b, c, d, e) {
wbytes(o, b, 0x6054B50); // skip disk
wbytes(o, b + 8, c);
wbytes(o, b + 10, c);
wbytes(o, b + 12, d);
wbytes(o, b + 16, e);
};
/**
* A pass-through stream to keep data uncompressed in a ZIP archive.
*/
var ZipPassThrough = /*#__PURE__*/ (function () {
/**
* Creates a pass-through stream that can be added to ZIP archives
* @param filename The filename to associate with this data stream
*/
function ZipPassThrough(filename) {
this.filename = filename;
this.c = crc();
this.size = 0;
this.compression = 0;
}
/**
* Processes a chunk and pushes to the output stream. You can override this
* method in a subclass for custom behavior, but by default this passes
* the data through. You must call this.ondata(err, chunk, final) at some
* point in this method.
* @param chunk The chunk to process
* @param final Whether this is the last chunk
*/
ZipPassThrough.prototype.process = function (chunk, final) {
this.ondata(null, chunk, final);
};
/**
* Pushes a chunk to be added. If you are subclassing this with a custom
* compression algorithm, note that you must push data from the source
* file only, pre-compression.
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
ZipPassThrough.prototype.push = function (chunk, final) {
if (!this.ondata)
err(5);
this.c.p(chunk);
this.size += chunk.length;
if (final)
this.crc = this.c.d();
// we shouldn't really do this cast, but properly handling ArrayBufferLike
// makes the API unergonomic with Buffer
this.process(chunk, final || false);
};
return ZipPassThrough;
}());
exports.ZipPassThrough = ZipPassThrough;
// I don't extend because TypeScript extension adds 1kB of runtime bloat
/**
* Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate
* for better performance
*/
var ZipDeflate = /*#__PURE__*/ (function () {
/**
* Creates a DEFLATE stream that can be added to ZIP archives
* @param filename The filename to associate with this data stream
* @param opts The compression options
*/
function ZipDeflate(filename, opts) {
var _this = this;
if (!opts)
opts = {};
ZipPassThrough.call(this, filename);
this.d = new Deflate(opts, function (dat, final) {
_this.ondata(null, dat, final);
});
this.compression = 8;
this.flag = dbf(opts.level);
}
ZipDeflate.prototype.process = function (chunk, final) {
try {
this.d.push(chunk, final);
}
catch (e) {
this.ondata(e, null, final);
}
};
/**
* Pushes a chunk to be deflated
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
ZipDeflate.prototype.push = function (chunk, final) {
ZipPassThrough.prototype.push.call(this, chunk, final);
};
return ZipDeflate;
}());
exports.ZipDeflate = ZipDeflate;
/**
* Asynchronous streaming DEFLATE compression for ZIP archives
*/
var AsyncZipDeflate = /*#__PURE__*/ (function () {
/**
* Creates an asynchronous DEFLATE stream that can be added to ZIP archives
* @param filename The filename to associate with this data stream
* @param opts The compression options
*/
function AsyncZipDeflate(filename, opts) {
var _this = this;
if (!opts)
opts = {};
ZipPassThrough.call(this, filename);
this.d = new AsyncDeflate(opts, function (err, dat, final) {
_this.ondata(err, dat, final);
});
this.compression = 8;
this.flag = dbf(opts.level);
this.terminate = this.d.terminate;
}
AsyncZipDeflate.prototype.process = function (chunk, final) {
this.d.push(chunk, final);
};
/**
* Pushes a chunk to be deflated
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
AsyncZipDeflate.prototype.push = function (chunk, final) {
ZipPassThrough.prototype.push.call(this, chunk, final);
};
return AsyncZipDeflate;
}());
exports.AsyncZipDeflate = AsyncZipDeflate;
// TODO: Better tree shaking
/**
* A zippable archive to which files can incrementally be added
*/
var Zip = /*#__PURE__*/ (function () {
/**
* Creates an empty ZIP archive to which files can be added
* @param cb The callback to call whenever data for the generated ZIP archive
* is available
*/
function Zip(cb) {
this.ondata = cb;
this.u = [];
this.d = 1;
}
/**
* Adds a file to the ZIP archive
* @param file The file stream to add
*/
Zip.prototype.add = function (file) {
var _this = this;
if (!this.ondata)
err(5);
// finishing or finished
if (this.d & 2)
this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false);
else {
var f = strToU8(file.filename), fl_1 = f.length;
var com = file.comment, o = com && strToU8(com);
var u = fl_1 != file.filename.length || (o && (com.length != o.length));
var hl_1 = fl_1 + exfl(file.extra) + 30;
if (fl_1 > 65535)
this.ondata(err(11, 0, 1), null, false);
var header = new u8(hl_1);
wzh(header, 0, file, f, u, -1);
var chks_1 = [header];
var pAll_1 = function () {
for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) {
var chk = chks_2[_i];
_this.ondata(null, chk, false);
}
chks_1 = [];
};
var tr_1 = this.d;
this.d = 0;
var ind_1 = this.u.length;
var uf_1 = mrg(file, {
f: f,
u: u,
o: o,
t: function () {
if (file.terminate)
file.terminate();
},
r: function () {
pAll_1();
if (tr_1) {
var nxt = _this.u[ind_1 + 1];
if (nxt)
nxt.r();
else
_this.d = 1;
}
tr_1 = 1;
}
});
var cl_1 = 0;
file.ondata = function (err, dat, final) {
if (err) {
_this.ondata(err, dat, final);
_this.terminate();
}
else {
cl_1 += dat.length;
chks_1.push(dat);
if (final) {
var dd = new u8(16);
wbytes(dd, 0, 0x8074B50);
wbytes(dd, 4, file.crc);
wbytes(dd, 8, cl_1);
wbytes(dd, 12, file.size);
chks_1.push(dd);
uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size;
if (tr_1)
uf_1.r();
tr_1 = 1;
}
else if (tr_1)
pAll_1();
}
};
this.u.push(uf_1);
}
};
/**
* Ends the process of adding files and prepares to emit the final chunks.
* This *must* be called after adding all desired files for the resulting
* ZIP file to work properly.
*/
Zip.prototype.end = function () {
var _this = this;
if (this.d & 2) {
this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true);
return;
}
if (this.d)
this.e();
else
this.u.push({
r: function () {
if (!(_this.d & 1))
return;
_this.u.splice(-1, 1);
_this.e();
},
t: function () { }
});
this.d = 3;
};
Zip.prototype.e = function () {
var bt = 0, l = 0, tl = 0;
for (var _i = 0, _a = this.u; _i < _a.length; _i++) {
var f = _a[_i];
tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0);
}
var out = new u8(tl + 22);
for (var _b = 0, _c = this.u; _b < _c.length; _b++) {
var f = _c[_b];
wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o);
bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b;
}
wzf(out, bt, this.u.length, tl, l);
this.ondata(null, out, true);
this.d = 2;
};
/**
* A method to terminate any internal workers used by the stream. Subsequent
* calls to add() will fail.
*/
Zip.prototype.terminate = function () {
for (var _i = 0, _a = this.u; _i < _a.length; _i++) {
var f = _a[_i];
f.t();
}
this.d = 2;
};
return Zip;
}());
exports.Zip = Zip;
function zip(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
var r = {};
fltn(data, '', r, opts);
var k = Object.keys(r);
var lft = k.length, o = 0, tot = 0;
var slft = lft, files = new Array(lft);
var term = [];
var tAll = function () {
for (var i = 0; i < term.length; ++i)
term[i]();
};
var cbd = function (a, b) {
mt(function () { cb(a, b); });
};
mt(function () { cbd = cb; });
var cbf = function () {
var out = new u8(tot + 22), oe = o, cdl = tot - o;
tot = 0;
for (var i = 0; i < slft; ++i) {
var f = files[i];
try {
var l = f.c.length;
wzh(out, tot, f, f.f, f.u, l);
var badd = 30 + f.f.length + exfl(f.extra);
var loc = tot + badd;
out.set(f.c, loc);
wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l;
}
catch (e) {
return cbd(e, null);
}
}
wzf(out, o, files.length, cdl, oe);
cbd(null, out);
};
if (!lft)
cbf();
var _loop_1 = function (i) {
var fn = k[i];
var _a = r[fn], file = _a[0], p = _a[1];
var c = crc(), size = file.length;
c.p(file);
var f = strToU8(fn), s = f.length;
var com = p.comment, m = com && strToU8(com), ms = m && m.length;
var exl = exfl(p.extra);
var compression = p.level == 0 ? 0 : 8;
var cbl = function (e, d) {
if (e) {
tAll();
cbd(e, null);
}
else {
var l = d.length;
files[i] = mrg(p, {
size: size,
crc: c.d(),
c: d,
f: f,
m: m,
u: s != fn.length || (m && (com.length != ms)),
compression: compression
});
o += 30 + s + exl + l;
tot += 76 + 2 * (s + exl) + (ms || 0) + l;
if (!--lft)
cbf();
}
};
if (s > 65535)
cbl(err(11, 0, 1), null);
if (!compression)
cbl(null, file);
else if (size < 160000) {
try {
cbl(null, deflateSync(file, p));
}
catch (e) {
cbl(e, null);
}
}
else
term.push(deflate(file, p, cbl));
};
// Cannot use lft because it can decrease
for (var i = 0; i < slft; ++i) {
_loop_1(i);
}
return tAll;
}
/**
* Synchronously creates a ZIP file. Prefer using `zip` for better performance
* with more than one file.
* @param data The directory structure for the ZIP archive
* @param opts The main options, merged with per-file options
* @returns The generated ZIP archive
*/
function zipSync(data, opts) {
if (!opts)
opts = {};
var r = {};
var files = [];
fltn(data, '', r, opts);
var o = 0;
var tot = 0;
for (var fn in r) {
var _a = r[fn], file = _a[0], p = _a[1];
var compression = p.level == 0 ? 0 : 8;
var f = strToU8(fn), s = f.length;
var com = p.comment, m = com && strToU8(com), ms = m && m.length;
var exl = exfl(p.extra);
if (s > 65535)
err(11);
var d = compression ? deflateSync(file, p) : file, l = d.length;
var c = crc();
c.p(file);
files.push(mrg(p, {
size: file.length,
crc: c.d(),
c: d,
f: f,
m: m,
u: s != fn.length || (m && (com.length != ms)),
o: o,
compression: compression
}));
o += 30 + s + exl + l;
tot += 76 + 2 * (s + exl) + (ms || 0) + l;
}
var out = new u8(tot + 22), oe = o, cdl = tot - o;
for (var i = 0; i < files.length; ++i) {
var f = files[i];
wzh(out, f.o, f, f.f, f.u, f.c.length);
var badd = 30 + f.f.length + exfl(f.extra);
out.set(f.c, f.o + badd);
wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
}
wzf(out, o, files.length, cdl, oe);
return out;
}
/**
* Streaming pass-through decompression for ZIP archives
*/
var UnzipPassThrough = /*#__PURE__*/ (function () {
function UnzipPassThrough() {
}
UnzipPassThrough.prototype.push = function (chunk, final) {
// same as ZipPassThrough: cast to retain Buffer ergonomics
this.ondata(null, chunk, final);
};
UnzipPassThrough.compression = 0;
return UnzipPassThrough;
}());
exports.UnzipPassThrough = UnzipPassThrough;
/**
* Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for
* better performance.
*/
var UnzipInflate = /*#__PURE__*/ (function () {
/**
* Creates a DEFLATE decompression that can be used in ZIP archives
*/
function UnzipInflate() {
var _this = this;
this.i = new Inflate(function (dat, final) {
_this.ondata(null, dat, final);
});
}
UnzipInflate.prototype.push = function (chunk, final) {
try {
this.i.push(chunk, final);
}
catch (e) {
this.ondata(e, null, final);
}
};
UnzipInflate.compression = 8;
return UnzipInflate;
}());
exports.UnzipInflate = UnzipInflate;
/**
* Asynchronous streaming DEFLATE decompression for ZIP archives
*/
var AsyncUnzipInflate = /*#__PURE__*/ (function () {
/**
* Creates a DEFLATE decompression that can be used in ZIP archives
*/
function AsyncUnzipInflate(_, sz) {
var _this = this;
if (sz < 320000) {
this.i = new Inflate(function (dat, final) {
_this.ondata(null, dat, final);
});
}
else {
this.i = new AsyncInflate(function (err, dat, final) {
_this.ondata(err, dat, final);
});
this.terminate = this.i.terminate;
}
}
AsyncUnzipInflate.prototype.push = function (chunk, final) {
if (this.i.terminate)
chunk = slc(chunk, 0);
this.i.push(chunk, final);
};
AsyncUnzipInflate.compression = 8;
return AsyncUnzipInflate;
}());
exports.AsyncUnzipInflate = AsyncUnzipInflate;
/**
* A ZIP archive decompression stream that emits files as they are discovered
*/
var Unzip = /*#__PURE__*/ (function () {
/**
* Creates a ZIP decompression stream
* @param cb The callback to call whenever a file in the ZIP archive is found
*/
function Unzip(cb) {
this.onfile = cb;
this.k = [];
this.o = {
0: UnzipPassThrough
};
this.p = et;
}
/**
* Pushes a chunk to be unzipped
* @param chunk The chunk to push
* @param final Whether this is the last chunk
*/
Unzip.prototype.push = function (chunk, final) {
var _this = this;
if (!this.onfile)
err(5);
if (!this.p)
err(4);
if (this.c > 0) {
var len = Math.min(this.c, chunk.length);
var toAdd = chunk.subarray(0, len);
this.c -= len;
if (this.d)
this.d.push(toAdd, !this.c);
else
this.k[0].push(toAdd);
chunk = chunk.subarray(len);
if (chunk.length)
return this.push(chunk, final);
}
else {
var f = 0, i = 0, is = void 0, buf = void 0;
if (!this.p.length)
buf = chunk;
else if (!chunk.length)
buf = this.p;
else {
buf = new u8(this.p.length + chunk.length);
buf.set(this.p), buf.set(chunk, this.p.length);
}
var l = buf.length, oc = this.c, add = oc && this.d;
var _loop_2 = function () {
var sig = b4(buf, i);
if (sig == 0x4034B50) {
f = 1, is = i;
this_1.d = null;
this_1.c = 0;
var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28);
if (l > i + 30 + fnl + es) {
var chks_3 = [];
this_1.k.unshift(chks_3);
f = 2;
var lsc = b4(buf, i + 18), lsu = b4(buf, i + 22);
var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);
var _a = z64hs(buf, i, es, 2, lsc, lsu, 0), sc_1 = _a[0], su_1 = _a[1], z64 = _a[3];
if (dd)
sc_1 = -1 - z64;
i += es;
this_1.c = sc_1;
var d_1;
var file_1 = {
name: fn_1,
compression: cmp_1,
start: function () {
if (!file_1.ondata)
err(5);
if (!sc_1)
file_1.ondata(null, et, true);
else {
var ctr = _this.o[cmp_1];
if (!ctr)
file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false);
d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);
d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); };
for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {
var dat = chks_4[_i];
d_1.push(dat, false);
}
if (_this.k[0] == chks_3 && _this.c)
_this.d = d_1;
else
d_1.push(et, true);
}
},
terminate: function () {
if (d_1 && d_1.terminate)
d_1.terminate();
}
};
if (sc_1 >= 0)
file_1.size = sc_1, file_1.originalSize = su_1;
this_1.onfile(file_1);
}
return "break";
}
else if (oc) {
if (sig == 0x8074B50) {
is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;
return "break";
}
else if (sig == 0x2014B50) {
is = i -= 4, f = 3, this_1.c = 0;
return "break";
}
}
};
var this_1 = this;
for (; i < l - 4; ++i) {
var state_1 = _loop_2();
if (state_1 === "break")
break;
}
this.p = et;
if (oc < 0) {
var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i);
if (add)
add.push(dat, !!f);
else
this.k[+(f == 2)].push(dat);
}
if (f & 2)
return this.push(buf.subarray(i), final);
this.p = buf.subarray(i);
}
if (final) {
if (this.c)
err(13);
this.p = null;
}
};
/**
* Registers a decoder with the stream, allowing for files compressed with
* the compression type provided to be expanded correctly
* @param decoder The decoder constructor
*/
Unzip.prototype.register = function (decoder) {
this.o[decoder.compression] = decoder;
};
return Unzip;
}());
exports.Unzip = Unzip;
var mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); };
function unzip(data, opts, cb) {
if (!cb)
cb = opts, opts = {};
if (typeof cb != 'function')
err(7);
var term = [];
var tAll = function () {
for (var i = 0; i < term.length; ++i)
term[i]();
};
var files = {};
var cbd = function (a, b) {
mt(function () { cb(a, b); });
};
mt(function () { cbd = cb; });
var e = data.length - 22;
for (; b4(data, e) != 0x6054B50; --e) {
if (!e || data.length - e > 65558) {
cbd(err(13, 0, 1), null);
return tAll;
}
}
;
var lft = b2(data, e + 8);
if (lft) {
var c = lft;
var o = b4(data, e + 16);
var z = b4(data, e - 20) == 0x7064B50;
if (z) {
var ze = b4(data, e - 12);
z = b4(data, ze) == 0x6064B50;
if (z) {
c = lft = b4(data, ze + 32);
o = b4(data, ze + 48);
}
}
var fltr = opts && opts.filter;
var _loop_3 = function (i) {
var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
o = no;
var cbl = function (e, d) {
if (e) {
tAll();
cbd(e, null);
}
else {
if (d)
files[fn] = d;
if (!--lft)
cbd(null, files);
}
};
if (!fltr || fltr({
name: fn,
size: sc,
originalSize: su,
compression: c_1
})) {
if (!c_1)
cbl(null, slc(data, b, b + sc));
else if (c_1 == 8) {
var infl = data.subarray(b, b + sc);
// Synchronously decompress under 512KB, or barely-compressed data
if (su < 524288 || sc > 0.8 * su) {
try {
cbl(null, inflateSync(infl, { out: new u8(su) }));
}
catch (e) {
cbl(e, null);
}
}
else
term.push(inflate(infl, { size: su }, cbl));
}
else
cbl(err(14, 'unknown compression type ' + c_1, 1), null);
}
else
cbl(null, null);
};
for (var i = 0; i < c; ++i) {
_loop_3(i);
}
}
else
cbd(null, {});
return tAll;
}
/**
* Synchronously decompresses a ZIP archive. Prefer using `unzip` for better
* performance with more than one file.
* @param data The raw compressed ZIP file
* @param opts The ZIP extraction options
* @returns The decompressed files
*/
function unzipSync(data, opts) {
var files = {};
var e = data.length - 22;
for (; b4(data, e) != 0x6054B50; --e) {
if (!e || data.length - e > 65558)
err(13);
}
;
var c = b2(data, e + 8);
if (!c)
return {};
var o = b4(data, e + 16);
var z = b4(data, e - 20) == 0x7064B50;
if (z) {
var ze = b4(data, e - 12);
z = b4(data, ze) == 0x6064B50;
if (z) {
c = b4(data, ze + 32);
o = b4(data, ze + 48);
}
}
var fltr = opts && opts.filter;
for (var i = 0; i < c; ++i) {
var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);
o = no;
if (!fltr || fltr({
name: fn,
size: sc,
originalSize: su,
compression: c_2
})) {
if (!c_2)
files[fn] = slc(data, b, b + sc);
else if (c_2 == 8)
files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
else
err(14, 'unknown compression type ' + c_2);
}
}
return files;
}
},{"./node-worker.cjs":26}],26:[function(require,module,exports){
"use strict";
var ch2 = {};
exports.default = (function (c, id, msg, transfer, cb) {
var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([
c + ';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})'
], { type: 'text/javascript' }))));
w.onmessage = function (e) {
var d = e.data, ed = d.$e$;
if (ed) {
var err = new Error(ed[0]);
err['code'] = ed[1];
err.stack = ed[2];
cb(err, null);
}
else
cb(null, d);
};
w.postMessage(msg, transfer);
return w;
});
},{}],27:[function(require,module,exports){
(function (global){(function (){
var $gfJaN$restructure = require("restructure");
var $gfJaN$swchelperscjs_define_propertycjs = require("@swc/helpers/cjs/_define_property.cjs");
var $gfJaN$swchelperscjs_ts_decoratecjs = require("@swc/helpers/cjs/_ts_decorate.cjs");
var $gfJaN$fastdeepequal = require("fast-deep-equal");
var $gfJaN$unicodeproperties = require("unicode-properties");
var $gfJaN$unicodetrie = require("unicode-trie");
var $gfJaN$dfa = require("dfa");
var $gfJaN$clone = require("clone");
var $gfJaN$tinyinflate = require("tiny-inflate");
var $gfJaN$brotlidecompressjs = require("brotli/decompress.js");
function $parcel$exportWildcard(dest, source) {
Object.keys(source).forEach(function(key) {
if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
return;
}
Object.defineProperty(dest, key, {
enumerable: true,
get: function get() {
return source[key];
}
});
});
return dest;
}
function $parcel$export(e, n, v, s) {
Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
}
function $parcel$interopDefault(a) {
return a && a.__esModule ? a.default : a;
}
var $59aa4ed98453e1d4$exports = {};
$parcel$export($59aa4ed98453e1d4$exports, "logErrors", () => $59aa4ed98453e1d4$export$bd5c5d8b8dcafd78);
$parcel$export($59aa4ed98453e1d4$exports, "registerFormat", () => $59aa4ed98453e1d4$export$36b2f24e97d43be);
$parcel$export($59aa4ed98453e1d4$exports, "create", () => $59aa4ed98453e1d4$export$185802fd694ee1f5);
$parcel$export($59aa4ed98453e1d4$exports, "defaultLanguage", () => $59aa4ed98453e1d4$export$42940898df819940);
$parcel$export($59aa4ed98453e1d4$exports, "setDefaultLanguage", () => $59aa4ed98453e1d4$export$5157e7780d44cc36);
let $59aa4ed98453e1d4$export$bd5c5d8b8dcafd78 = false;
let $59aa4ed98453e1d4$var$formats = [];
function $59aa4ed98453e1d4$export$36b2f24e97d43be(format) {
$59aa4ed98453e1d4$var$formats.push(format);
}
function $59aa4ed98453e1d4$export$185802fd694ee1f5(buffer, postscriptName) {
for(let i = 0; i < $59aa4ed98453e1d4$var$formats.length; i++){
let format = $59aa4ed98453e1d4$var$formats[i];
if (format.probe(buffer)) {
let font = new format(new (0, $gfJaN$restructure.DecodeStream)(buffer));
if (postscriptName) return font.getFont(postscriptName);
return font;
}
}
throw new Error('Unknown font format');
}
let $59aa4ed98453e1d4$export$42940898df819940 = 'en';
function $59aa4ed98453e1d4$export$5157e7780d44cc36(lang = 'en') {
$59aa4ed98453e1d4$export$42940898df819940 = lang;
}
/**
* This decorator caches the results of a getter or method such that
* the results are lazily computed once, and then cached.
* @private
*/ function $3bda6911913b43f0$export$69a3209f1a06c04d(target, key, descriptor) {
if (descriptor.get) {
let get = descriptor.get;
descriptor.get = function() {
let value = get.call(this);
Object.defineProperty(this, key, {
value: value
});
return value;
};
} else if (typeof descriptor.value === 'function') {
let fn = descriptor.value;
return {
get () {
let cache = new Map;
function memoized(...args) {
let key = args.length > 0 ? args[0] : 'value';
if (cache.has(key)) return cache.get(key);
let result = fn.apply(this, args);
cache.set(key, result);
return result;
}
Object.defineProperty(this, key, {
value: memoized
});
return memoized;
}
};
}
}
let $e4ae0436c91af89f$var$SubHeader = new $gfJaN$restructure.Struct({
firstCode: $gfJaN$restructure.uint16,
entryCount: $gfJaN$restructure.uint16,
idDelta: $gfJaN$restructure.int16,
idRangeOffset: $gfJaN$restructure.uint16
});
let $e4ae0436c91af89f$var$CmapGroup = new $gfJaN$restructure.Struct({
startCharCode: $gfJaN$restructure.uint32,
endCharCode: $gfJaN$restructure.uint32,
glyphID: $gfJaN$restructure.uint32
});
let $e4ae0436c91af89f$var$UnicodeValueRange = new $gfJaN$restructure.Struct({
startUnicodeValue: $gfJaN$restructure.uint24,
additionalCount: $gfJaN$restructure.uint8
});
let $e4ae0436c91af89f$var$UVSMapping = new $gfJaN$restructure.Struct({
unicodeValue: $gfJaN$restructure.uint24,
glyphID: $gfJaN$restructure.uint16
});
let $e4ae0436c91af89f$var$DefaultUVS = new $gfJaN$restructure.Array($e4ae0436c91af89f$var$UnicodeValueRange, $gfJaN$restructure.uint32);
let $e4ae0436c91af89f$var$NonDefaultUVS = new $gfJaN$restructure.Array($e4ae0436c91af89f$var$UVSMapping, $gfJaN$restructure.uint32);
let $e4ae0436c91af89f$var$VarSelectorRecord = new $gfJaN$restructure.Struct({
varSelector: $gfJaN$restructure.uint24,
defaultUVS: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $e4ae0436c91af89f$var$DefaultUVS, {
type: 'parent'
}),
nonDefaultUVS: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $e4ae0436c91af89f$var$NonDefaultUVS, {
type: 'parent'
})
});
let $e4ae0436c91af89f$var$CmapSubtable = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
0: {
length: $gfJaN$restructure.uint16,
language: $gfJaN$restructure.uint16,
codeMap: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint8, 256)
},
2: {
length: $gfJaN$restructure.uint16,
language: $gfJaN$restructure.uint16,
subHeaderKeys: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 256),
subHeaderCount: (t)=>Math.max.apply(Math, t.subHeaderKeys),
subHeaders: new $gfJaN$restructure.LazyArray($e4ae0436c91af89f$var$SubHeader, 'subHeaderCount'),
glyphIndexArray: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, 'subHeaderCount')
},
4: {
length: $gfJaN$restructure.uint16,
language: $gfJaN$restructure.uint16,
segCountX2: $gfJaN$restructure.uint16,
segCount: (t)=>t.segCountX2 >> 1,
searchRange: $gfJaN$restructure.uint16,
entrySelector: $gfJaN$restructure.uint16,
rangeShift: $gfJaN$restructure.uint16,
endCode: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, 'segCount'),
reservedPad: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
startCode: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, 'segCount'),
idDelta: new $gfJaN$restructure.LazyArray($gfJaN$restructure.int16, 'segCount'),
idRangeOffset: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, 'segCount'),
glyphIndexArray: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, (t)=>(t.length - t._currentOffset) / 2)
},
6: {
length: $gfJaN$restructure.uint16,
language: $gfJaN$restructure.uint16,
firstCode: $gfJaN$restructure.uint16,
entryCount: $gfJaN$restructure.uint16,
glyphIndices: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, 'entryCount')
},
8: {
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
length: $gfJaN$restructure.uint32,
language: $gfJaN$restructure.uint16,
is32: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint8, 8192),
nGroups: $gfJaN$restructure.uint32,
groups: new $gfJaN$restructure.LazyArray($e4ae0436c91af89f$var$CmapGroup, 'nGroups')
},
10: {
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
length: $gfJaN$restructure.uint32,
language: $gfJaN$restructure.uint32,
firstCode: $gfJaN$restructure.uint32,
entryCount: $gfJaN$restructure.uint32,
glyphIndices: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, 'numChars')
},
12: {
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
length: $gfJaN$restructure.uint32,
language: $gfJaN$restructure.uint32,
nGroups: $gfJaN$restructure.uint32,
groups: new $gfJaN$restructure.LazyArray($e4ae0436c91af89f$var$CmapGroup, 'nGroups')
},
13: {
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
length: $gfJaN$restructure.uint32,
language: $gfJaN$restructure.uint32,
nGroups: $gfJaN$restructure.uint32,
groups: new $gfJaN$restructure.LazyArray($e4ae0436c91af89f$var$CmapGroup, 'nGroups')
},
14: {
length: $gfJaN$restructure.uint32,
numRecords: $gfJaN$restructure.uint32,
varSelectors: new $gfJaN$restructure.LazyArray($e4ae0436c91af89f$var$VarSelectorRecord, 'numRecords')
}
});
let $e4ae0436c91af89f$var$CmapEntry = new $gfJaN$restructure.Struct({
platformID: $gfJaN$restructure.uint16,
encodingID: $gfJaN$restructure.uint16,
table: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $e4ae0436c91af89f$var$CmapSubtable, {
type: 'parent',
lazy: true
})
});
var // character to glyph mapping
$e4ae0436c91af89f$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
numSubtables: $gfJaN$restructure.uint16,
tables: new $gfJaN$restructure.Array($e4ae0436c91af89f$var$CmapEntry, 'numSubtables')
});
var // font header
$55a60976afb7c261$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.int32,
revision: $gfJaN$restructure.int32,
checkSumAdjustment: $gfJaN$restructure.uint32,
magicNumber: $gfJaN$restructure.uint32,
flags: $gfJaN$restructure.uint16,
unitsPerEm: $gfJaN$restructure.uint16,
created: new $gfJaN$restructure.Array($gfJaN$restructure.int32, 2),
modified: new $gfJaN$restructure.Array($gfJaN$restructure.int32, 2),
xMin: $gfJaN$restructure.int16,
yMin: $gfJaN$restructure.int16,
xMax: $gfJaN$restructure.int16,
yMax: $gfJaN$restructure.int16,
macStyle: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint16, [
'bold',
'italic',
'underline',
'outline',
'shadow',
'condensed',
'extended'
]),
lowestRecPPEM: $gfJaN$restructure.uint16,
fontDirectionHint: $gfJaN$restructure.int16,
indexToLocFormat: $gfJaN$restructure.int16,
glyphDataFormat: $gfJaN$restructure.int16 // 0 for current format
});
var // horizontal header
$dde72b7b5b650596$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.int32,
ascent: $gfJaN$restructure.int16,
descent: $gfJaN$restructure.int16,
lineGap: $gfJaN$restructure.int16,
advanceWidthMax: $gfJaN$restructure.uint16,
minLeftSideBearing: $gfJaN$restructure.int16,
minRightSideBearing: $gfJaN$restructure.int16,
xMaxExtent: $gfJaN$restructure.int16,
caretSlopeRise: $gfJaN$restructure.int16,
caretSlopeRun: $gfJaN$restructure.int16,
caretOffset: $gfJaN$restructure.int16,
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.int16, 4),
metricDataFormat: $gfJaN$restructure.int16,
numberOfMetrics: $gfJaN$restructure.uint16 // Number of advance widths in 'hmtx' table
});
let $a7c40184072c9a5b$var$HmtxEntry = new $gfJaN$restructure.Struct({
advance: $gfJaN$restructure.uint16,
bearing: $gfJaN$restructure.int16
});
var $a7c40184072c9a5b$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
metrics: new $gfJaN$restructure.LazyArray($a7c40184072c9a5b$var$HmtxEntry, (t)=>t.parent.hhea.numberOfMetrics),
bearings: new $gfJaN$restructure.LazyArray($gfJaN$restructure.int16, (t)=>t.parent.maxp.numGlyphs - t.parent.hhea.numberOfMetrics)
});
var // maxiumum profile
$521197722369f691$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.int32,
numGlyphs: $gfJaN$restructure.uint16,
maxPoints: $gfJaN$restructure.uint16,
maxContours: $gfJaN$restructure.uint16,
maxComponentPoints: $gfJaN$restructure.uint16,
maxComponentContours: $gfJaN$restructure.uint16,
maxZones: $gfJaN$restructure.uint16,
maxTwilightPoints: $gfJaN$restructure.uint16,
maxStorage: $gfJaN$restructure.uint16,
maxFunctionDefs: $gfJaN$restructure.uint16,
maxInstructionDefs: $gfJaN$restructure.uint16,
maxStackElements: $gfJaN$restructure.uint16,
maxSizeOfInstructions: $gfJaN$restructure.uint16,
maxComponentElements: $gfJaN$restructure.uint16,
maxComponentDepth: $gfJaN$restructure.uint16 // Maximum levels of recursion; 1 for simple components
});
/**
* Gets an encoding name from platform, encoding, and language ids.
* Returned encoding names can be used in iconv-lite to decode text.
*/ function $e2613b812f052cbe$export$badc544e0651b6b1(platformID, encodingID, languageID = 0) {
if (platformID === 1 && $e2613b812f052cbe$export$479e671907f486d1[languageID]) return $e2613b812f052cbe$export$479e671907f486d1[languageID];
return $e2613b812f052cbe$export$6fef87b7618bdf0b[platformID][encodingID];
}
const $e2613b812f052cbe$var$SINGLE_BYTE_ENCODINGS = new Set([
'x-mac-roman',
'x-mac-cyrillic',
'iso-8859-6',
'iso-8859-8'
]);
const $e2613b812f052cbe$var$MAC_ENCODINGS = {
'x-mac-croatian': "\xc4\xc5\xc7\xc9\xd1\xd6\xdc\xe1\xe0\xe2\xe4\xe3\xe5\xe7\xe9\xe8\xea\xeb\xed\xec\xee\xef\xf1\xf3\xf2\xf4\xf6\xf5\xfa\xf9\xfb\xfc\u2020\xb0\xa2\xa3\xa7\u2022\xb6\xdf\xae\u0160\u2122\xb4\xa8\u2260\u017D\xd8\u221E\xb1\u2264\u2265\u2206\xb5\u2202\u2211\u220F\u0161\u222B\xaa\xba\u03A9\u017E\xf8\xbf\xa1\xac\u221A\u0192\u2248\u0106\xab\u010C\u2026 \xc0\xc3\xd5\u0152\u0153\u0110\u2014\u201C\u201D\u2018\u2019\xf7\u25CA\uF8FF\xa9\u2044\u20AC\u2039\u203A\xc6\xbb\u2013\xb7\u201A\u201E\u2030\xc2\u0107\xc1\u010D\xc8\xcd\xce\xcf\xcc\xd3\xd4\u0111\xd2\xda\xdb\xd9\u0131\u02C6\u02DC\xaf\u03C0\xcb\u02DA\xb8\xca\xe6\u02C7",
'x-mac-gaelic': "\xc4\xc5\xc7\xc9\xd1\xd6\xdc\xe1\xe0\xe2\xe4\xe3\xe5\xe7\xe9\xe8\xea\xeb\xed\xec\xee\xef\xf1\xf3\xf2\xf4\xf6\xf5\xfa\xf9\xfb\xfc\u2020\xb0\xa2\xa3\xa7\u2022\xb6\xdf\xae\xa9\u2122\xb4\xa8\u2260\xc6\xd8\u1E02\xb1\u2264\u2265\u1E03\u010A\u010B\u1E0A\u1E0B\u1E1E\u1E1F\u0120\u0121\u1E40\xe6\xf8\u1E41\u1E56\u1E57\u027C\u0192\u017F\u1E60\xab\xbb\u2026 \xc0\xc3\xd5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\u1E61\u1E9B\xff\u0178\u1E6A\u20AC\u2039\u203A\u0176\u0177\u1E6B\xb7\u1EF2\u1EF3\u204A\xc2\xca\xc1\xcb\xc8\xcd\xce\xcf\xcc\xd3\xd4\u2663\xd2\xda\xdb\xd9\u0131\xdd\xfd\u0174\u0175\u1E84\u1E85\u1E80\u1E81\u1E82\u1E83",
'x-mac-greek': "\xc4\xb9\xb2\xc9\xb3\xd6\xdc\u0385\xe0\xe2\xe4\u0384\xa8\xe7\xe9\xe8\xea\xeb\xa3\u2122\xee\xef\u2022\xbd\u2030\xf4\xf6\xa6\u20AC\xf9\xfb\xfc\u2020\u0393\u0394\u0398\u039B\u039E\u03A0\xdf\xae\xa9\u03A3\u03AA\xa7\u2260\xb0\xb7\u0391\xb1\u2264\u2265\xa5\u0392\u0395\u0396\u0397\u0399\u039A\u039C\u03A6\u03AB\u03A8\u03A9\u03AC\u039D\xac\u039F\u03A1\u2248\u03A4\xab\xbb\u2026 \u03A5\u03A7\u0386\u0388\u0153\u2013\u2015\u201C\u201D\u2018\u2019\xf7\u0389\u038A\u038C\u038E\u03AD\u03AE\u03AF\u03CC\u038F\u03CD\u03B1\u03B2\u03C8\u03B4\u03B5\u03C6\u03B3\u03B7\u03B9\u03BE\u03BA\u03BB\u03BC\u03BD\u03BF\u03C0\u03CE\u03C1\u03C3\u03C4\u03B8\u03C9\u03C2\u03C7\u03C5\u03B6\u03CA\u03CB\u0390\u03B0\xad",
'x-mac-icelandic': "\xc4\xc5\xc7\xc9\xd1\xd6\xdc\xe1\xe0\xe2\xe4\xe3\xe5\xe7\xe9\xe8\xea\xeb\xed\xec\xee\xef\xf1\xf3\xf2\xf4\xf6\xf5\xfa\xf9\xfb\xfc\xdd\xb0\xa2\xa3\xa7\u2022\xb6\xdf\xae\xa9\u2122\xb4\xa8\u2260\xc6\xd8\u221E\xb1\u2264\u2265\xa5\xb5\u2202\u2211\u220F\u03C0\u222B\xaa\xba\u03A9\xe6\xf8\xbf\xa1\xac\u221A\u0192\u2248\u2206\xab\xbb\u2026 \xc0\xc3\xd5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xf7\u25CA\xff\u0178\u2044\u20AC\xd0\xf0\xde\xfe\xfd\xb7\u201A\u201E\u2030\xc2\xca\xc1\xcb\xc8\xcd\xce\xcf\xcc\xd3\xd4\uF8FF\xd2\xda\xdb\xd9\u0131\u02C6\u02DC\xaf\u02D8\u02D9\u02DA\xb8\u02DD\u02DB\u02C7",
'x-mac-inuit': "\u1403\u1404\u1405\u1406\u140A\u140B\u1431\u1432\u1433\u1434\u1438\u1439\u1449\u144E\u144F\u1450\u1451\u1455\u1456\u1466\u146D\u146E\u146F\u1470\u1472\u1473\u1483\u148B\u148C\u148D\u148E\u1490\u1491\xb0\u14A1\u14A5\u14A6\u2022\xb6\u14A7\xae\xa9\u2122\u14A8\u14AA\u14AB\u14BB\u14C2\u14C3\u14C4\u14C5\u14C7\u14C8\u14D0\u14EF\u14F0\u14F1\u14F2\u14F4\u14F5\u1505\u14D5\u14D6\u14D7\u14D8\u14DA\u14DB\u14EA\u1528\u1529\u152A\u152B\u152D\u2026 \u152E\u153E\u1555\u1556\u1557\u2013\u2014\u201C\u201D\u2018\u2019\u1558\u1559\u155A\u155D\u1546\u1547\u1548\u1549\u154B\u154C\u1550\u157F\u1580\u1581\u1582\u1583\u1584\u1585\u158F\u1590\u1591\u1592\u1593\u1594\u1595\u1671\u1672\u1673\u1674\u1675\u1676\u1596\u15A0\u15A1\u15A2\u15A3\u15A4\u15A5\u15A6\u157C\u0141\u0142",
'x-mac-ce': "\xc4\u0100\u0101\xc9\u0104\xd6\xdc\xe1\u0105\u010C\xe4\u010D\u0106\u0107\xe9\u0179\u017A\u010E\xed\u010F\u0112\u0113\u0116\xf3\u0117\xf4\xf6\xf5\xfa\u011A\u011B\xfc\u2020\xb0\u0118\xa3\xa7\u2022\xb6\xdf\xae\xa9\u2122\u0119\xa8\u2260\u0123\u012E\u012F\u012A\u2264\u2265\u012B\u0136\u2202\u2211\u0142\u013B\u013C\u013D\u013E\u0139\u013A\u0145\u0146\u0143\xac\u221A\u0144\u0147\u2206\xab\xbb\u2026 \u0148\u0150\xd5\u0151\u014C\u2013\u2014\u201C\u201D\u2018\u2019\xf7\u25CA\u014D\u0154\u0155\u0158\u2039\u203A\u0159\u0156\u0157\u0160\u201A\u201E\u0161\u015A\u015B\xc1\u0164\u0165\xcd\u017D\u017E\u016A\xd3\xd4\u016B\u016E\xda\u016F\u0170\u0171\u0172\u0173\xdd\xfd\u0137\u017B\u0141\u017C\u0122\u02C7",
'x-mac-romanian': "\xc4\xc5\xc7\xc9\xd1\xd6\xdc\xe1\xe0\xe2\xe4\xe3\xe5\xe7\xe9\xe8\xea\xeb\xed\xec\xee\xef\xf1\xf3\xf2\xf4\xf6\xf5\xfa\xf9\xfb\xfc\u2020\xb0\xa2\xa3\xa7\u2022\xb6\xdf\xae\xa9\u2122\xb4\xa8\u2260\u0102\u0218\u221E\xb1\u2264\u2265\xa5\xb5\u2202\u2211\u220F\u03C0\u222B\xaa\xba\u03A9\u0103\u0219\xbf\xa1\xac\u221A\u0192\u2248\u2206\xab\xbb\u2026 \xc0\xc3\xd5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xf7\u25CA\xff\u0178\u2044\u20AC\u2039\u203A\u021A\u021B\u2021\xb7\u201A\u201E\u2030\xc2\xca\xc1\xcb\xc8\xcd\xce\xcf\xcc\xd3\xd4\uF8FF\xd2\xda\xdb\xd9\u0131\u02C6\u02DC\xaf\u02D8\u02D9\u02DA\xb8\u02DD\u02DB\u02C7",
'x-mac-turkish': "\xc4\xc5\xc7\xc9\xd1\xd6\xdc\xe1\xe0\xe2\xe4\xe3\xe5\xe7\xe9\xe8\xea\xeb\xed\xec\xee\xef\xf1\xf3\xf2\xf4\xf6\xf5\xfa\xf9\xfb\xfc\u2020\xb0\xa2\xa3\xa7\u2022\xb6\xdf\xae\xa9\u2122\xb4\xa8\u2260\xc6\xd8\u221E\xb1\u2264\u2265\xa5\xb5\u2202\u2211\u220F\u03C0\u222B\xaa\xba\u03A9\xe6\xf8\xbf\xa1\xac\u221A\u0192\u2248\u2206\xab\xbb\u2026 \xc0\xc3\xd5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xf7\u25CA\xff\u0178\u011E\u011F\u0130\u0131\u015E\u015F\u2021\xb7\u201A\u201E\u2030\xc2\xca\xc1\xcb\xc8\xcd\xce\xcf\xcc\xd3\xd4\uF8FF\xd2\xda\xdb\xd9\uF8A0\u02C6\u02DC\xaf\u02D8\u02D9\u02DA\xb8\u02DD\u02DB\u02C7"
};
const $e2613b812f052cbe$var$encodingCache = new Map();
function $e2613b812f052cbe$export$1dceb3c14ed68bee(encoding) {
let cached = $e2613b812f052cbe$var$encodingCache.get(encoding);
if (cached) return cached;
// These encodings aren't supported by TextDecoder.
let mapping = $e2613b812f052cbe$var$MAC_ENCODINGS[encoding];
if (mapping) {
let res = new Map();
for(let i = 0; i < mapping.length; i++)res.set(mapping.charCodeAt(i), 0x80 + i);
$e2613b812f052cbe$var$encodingCache.set(encoding, res);
return res;
}
// Only single byte encodings can be mapped 1:1.
if ($e2613b812f052cbe$var$SINGLE_BYTE_ENCODINGS.has(encoding)) {
// TextEncoder only supports utf8, whereas TextDecoder supports legacy encodings.
// Use this to create a mapping of code points.
let decoder = new TextDecoder(encoding);
let mapping = new Uint8Array(0x80);
for(let i = 0; i < 0x80; i++)mapping[i] = 0x80 + i;
let res = new Map();
let s = decoder.decode(mapping);
for(let i = 0; i < 0x80; i++)res.set(s.charCodeAt(i), 0x80 + i);
$e2613b812f052cbe$var$encodingCache.set(encoding, res);
return res;
}
}
const $e2613b812f052cbe$export$6fef87b7618bdf0b = [
// unicode
[
'utf-16be',
'utf-16be',
'utf-16be',
'utf-16be',
'utf-16be',
'utf-16be',
'utf-16be'
],
// macintosh
// Mappings available at http://unicode.org/Public/MAPPINGS/VENDORS/APPLE/
// 0 Roman 17 Malayalam
// 1 Japanese 18 Sinhalese
// 2 Traditional Chinese 19 Burmese
// 3 Korean 20 Khmer
// 4 Arabic 21 Thai
// 5 Hebrew 22 Laotian
// 6 Greek 23 Georgian
// 7 Russian 24 Armenian
// 8 RSymbol 25 Simplified Chinese
// 9 Devanagari 26 Tibetan
// 10 Gurmukhi 27 Mongolian
// 11 Gujarati 28 Geez
// 12 Oriya 29 Slavic
// 13 Bengali 30 Vietnamese
// 14 Tamil 31 Sindhi
// 15 Telugu 32 (Uninterpreted)
// 16 Kannada
[
'x-mac-roman',
'shift-jis',
'big5',
'euc-kr',
'iso-8859-6',
'iso-8859-8',
'x-mac-greek',
'x-mac-cyrillic',
'x-mac-symbol',
'x-mac-devanagari',
'x-mac-gurmukhi',
'x-mac-gujarati',
'Oriya',
'Bengali',
'Tamil',
'Telugu',
'Kannada',
'Malayalam',
'Sinhalese',
'Burmese',
'Khmer',
'iso-8859-11',
'Laotian',
'Georgian',
'Armenian',
'gbk',
'Tibetan',
'Mongolian',
'Geez',
'x-mac-ce',
'Vietnamese',
'Sindhi'
],
// ISO (deprecated)
[
'ascii',
null,
'iso-8859-1'
],
// windows
// Docs here: http://msdn.microsoft.com/en-us/library/system.text.encoding(v=vs.110).aspx
[
'symbol',
'utf-16be',
'shift-jis',
'gb18030',
'big5',
'euc-kr',
'johab',
null,
null,
null,
'utf-16be'
]
];
const $e2613b812f052cbe$export$479e671907f486d1 = {
15: 'x-mac-icelandic',
17: 'x-mac-turkish',
18: 'x-mac-croatian',
24: 'x-mac-ce',
25: 'x-mac-ce',
26: 'x-mac-ce',
27: 'x-mac-ce',
28: 'x-mac-ce',
30: 'x-mac-icelandic',
37: 'x-mac-romanian',
38: 'x-mac-ce',
39: 'x-mac-ce',
40: 'x-mac-ce',
143: 'x-mac-inuit',
146: 'x-mac-gaelic'
};
const $e2613b812f052cbe$export$2092376fd002e13 = [
// unicode
[],
{
0: 'en',
30: 'fo',
60: 'ks',
90: 'rw',
1: 'fr',
31: 'fa',
61: 'ku',
91: 'rn',
2: 'de',
32: 'ru',
62: 'sd',
92: 'ny',
3: 'it',
33: 'zh',
63: 'bo',
93: 'mg',
4: 'nl',
34: 'nl-BE',
64: 'ne',
94: 'eo',
5: 'sv',
35: 'ga',
65: 'sa',
128: 'cy',
6: 'es',
36: 'sq',
66: 'mr',
129: 'eu',
7: 'da',
37: 'ro',
67: 'bn',
130: 'ca',
8: 'pt',
38: 'cz',
68: 'as',
131: 'la',
9: 'no',
39: 'sk',
69: 'gu',
132: 'qu',
10: 'he',
40: 'si',
70: 'pa',
133: 'gn',
11: 'ja',
41: 'yi',
71: 'or',
134: 'ay',
12: 'ar',
42: 'sr',
72: 'ml',
135: 'tt',
13: 'fi',
43: 'mk',
73: 'kn',
136: 'ug',
14: 'el',
44: 'bg',
74: 'ta',
137: 'dz',
15: 'is',
45: 'uk',
75: 'te',
138: 'jv',
16: 'mt',
46: 'be',
76: 'si',
139: 'su',
17: 'tr',
47: 'uz',
77: 'my',
140: 'gl',
18: 'hr',
48: 'kk',
78: 'km',
141: 'af',
19: 'zh-Hant',
49: 'az-Cyrl',
79: 'lo',
142: 'br',
20: 'ur',
50: 'az-Arab',
80: 'vi',
143: 'iu',
21: 'hi',
51: 'hy',
81: 'id',
144: 'gd',
22: 'th',
52: 'ka',
82: 'tl',
145: 'gv',
23: 'ko',
53: 'mo',
83: 'ms',
146: 'ga',
24: 'lt',
54: 'ky',
84: 'ms-Arab',
147: 'to',
25: 'pl',
55: 'tg',
85: 'am',
148: 'el-polyton',
26: 'hu',
56: 'tk',
86: 'ti',
149: 'kl',
27: 'es',
57: 'mn-CN',
87: 'om',
150: 'az',
28: 'lv',
58: 'mn',
88: 'so',
151: 'nn',
29: 'se',
59: 'ps',
89: 'sw'
},
// ISO (deprecated)
[],
{
0x0436: 'af',
0x4009: 'en-IN',
0x0487: 'rw',
0x0432: 'tn',
0x041C: 'sq',
0x1809: 'en-IE',
0x0441: 'sw',
0x045B: 'si',
0x0484: 'gsw',
0x2009: 'en-JM',
0x0457: 'kok',
0x041B: 'sk',
0x045E: 'am',
0x4409: 'en-MY',
0x0412: 'ko',
0x0424: 'sl',
0x1401: 'ar-DZ',
0x1409: 'en-NZ',
0x0440: 'ky',
0x2C0A: 'es-AR',
0x3C01: 'ar-BH',
0x3409: 'en-PH',
0x0454: 'lo',
0x400A: 'es-BO',
0x0C01: 'ar',
0x4809: 'en-SG',
0x0426: 'lv',
0x340A: 'es-CL',
0x0801: 'ar-IQ',
0x1C09: 'en-ZA',
0x0427: 'lt',
0x240A: 'es-CO',
0x2C01: 'ar-JO',
0x2C09: 'en-TT',
0x082E: 'dsb',
0x140A: 'es-CR',
0x3401: 'ar-KW',
0x0809: 'en-GB',
0x046E: 'lb',
0x1C0A: 'es-DO',
0x3001: 'ar-LB',
0x0409: 'en',
0x042F: 'mk',
0x300A: 'es-EC',
0x1001: 'ar-LY',
0x3009: 'en-ZW',
0x083E: 'ms-BN',
0x440A: 'es-SV',
0x1801: 'ary',
0x0425: 'et',
0x043E: 'ms',
0x100A: 'es-GT',
0x2001: 'ar-OM',
0x0438: 'fo',
0x044C: 'ml',
0x480A: 'es-HN',
0x4001: 'ar-QA',
0x0464: 'fil',
0x043A: 'mt',
0x080A: 'es-MX',
0x0401: 'ar-SA',
0x040B: 'fi',
0x0481: 'mi',
0x4C0A: 'es-NI',
0x2801: 'ar-SY',
0x080C: 'fr-BE',
0x047A: 'arn',
0x180A: 'es-PA',
0x1C01: 'aeb',
0x0C0C: 'fr-CA',
0x044E: 'mr',
0x3C0A: 'es-PY',
0x3801: 'ar-AE',
0x040C: 'fr',
0x047C: 'moh',
0x280A: 'es-PE',
0x2401: 'ar-YE',
0x140C: 'fr-LU',
0x0450: 'mn',
0x500A: 'es-PR',
0x042B: 'hy',
0x180C: 'fr-MC',
0x0850: 'mn-CN',
0x0C0A: 'es',
0x044D: 'as',
0x100C: 'fr-CH',
0x0461: 'ne',
0x040A: 'es',
0x082C: 'az-Cyrl',
0x0462: 'fy',
0x0414: 'nb',
0x540A: 'es-US',
0x042C: 'az',
0x0456: 'gl',
0x0814: 'nn',
0x380A: 'es-UY',
0x046D: 'ba',
0x0437: 'ka',
0x0482: 'oc',
0x200A: 'es-VE',
0x042D: 'eu',
0x0C07: 'de-AT',
0x0448: 'or',
0x081D: 'sv-FI',
0x0423: 'be',
0x0407: 'de',
0x0463: 'ps',
0x041D: 'sv',
0x0845: 'bn',
0x1407: 'de-LI',
0x0415: 'pl',
0x045A: 'syr',
0x0445: 'bn-IN',
0x1007: 'de-LU',
0x0416: 'pt',
0x0428: 'tg',
0x201A: 'bs-Cyrl',
0x0807: 'de-CH',
0x0816: 'pt-PT',
0x085F: 'tzm',
0x141A: 'bs',
0x0408: 'el',
0x0446: 'pa',
0x0449: 'ta',
0x047E: 'br',
0x046F: 'kl',
0x046B: 'qu-BO',
0x0444: 'tt',
0x0402: 'bg',
0x0447: 'gu',
0x086B: 'qu-EC',
0x044A: 'te',
0x0403: 'ca',
0x0468: 'ha',
0x0C6B: 'qu',
0x041E: 'th',
0x0C04: 'zh-HK',
0x040D: 'he',
0x0418: 'ro',
0x0451: 'bo',
0x1404: 'zh-MO',
0x0439: 'hi',
0x0417: 'rm',
0x041F: 'tr',
0x0804: 'zh',
0x040E: 'hu',
0x0419: 'ru',
0x0442: 'tk',
0x1004: 'zh-SG',
0x040F: 'is',
0x243B: 'smn',
0x0480: 'ug',
0x0404: 'zh-TW',
0x0470: 'ig',
0x103B: 'smj-NO',
0x0422: 'uk',
0x0483: 'co',
0x0421: 'id',
0x143B: 'smj',
0x042E: 'hsb',
0x041A: 'hr',
0x045D: 'iu',
0x0C3B: 'se-FI',
0x0420: 'ur',
0x101A: 'hr-BA',
0x085D: 'iu-Latn',
0x043B: 'se',
0x0843: 'uz-Cyrl',
0x0405: 'cs',
0x083C: 'ga',
0x083B: 'se-SE',
0x0443: 'uz',
0x0406: 'da',
0x0434: 'xh',
0x203B: 'sms',
0x042A: 'vi',
0x048C: 'prs',
0x0435: 'zu',
0x183B: 'sma-NO',
0x0452: 'cy',
0x0465: 'dv',
0x0410: 'it',
0x1C3B: 'sms',
0x0488: 'wo',
0x0813: 'nl-BE',
0x0810: 'it-CH',
0x044F: 'sa',
0x0485: 'sah',
0x0413: 'nl',
0x0411: 'ja',
0x1C1A: 'sr-Cyrl-BA',
0x0478: 'ii',
0x0C09: 'en-AU',
0x044B: 'kn',
0x0C1A: 'sr',
0x046A: 'yo',
0x2809: 'en-BZ',
0x043F: 'kk',
0x181A: 'sr-Latn-BA',
0x1009: 'en-CA',
0x0453: 'km',
0x081A: 'sr-Latn',
0x2409: 'en-029',
0x0486: 'quc',
0x046C: 'nso'
}
];
let $51a9f4feb3a3b2b1$var$NameRecord = new $gfJaN$restructure.Struct({
platformID: $gfJaN$restructure.uint16,
encodingID: $gfJaN$restructure.uint16,
languageID: $gfJaN$restructure.uint16,
nameID: $gfJaN$restructure.uint16,
length: $gfJaN$restructure.uint16,
string: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new $gfJaN$restructure.String('length', (t)=>(0, $e2613b812f052cbe$export$badc544e0651b6b1)(t.platformID, t.encodingID, t.languageID)), {
type: 'parent',
relativeTo: (ctx)=>ctx.parent.stringOffset,
allowNull: false
})
});
let $51a9f4feb3a3b2b1$var$LangTagRecord = new $gfJaN$restructure.Struct({
length: $gfJaN$restructure.uint16,
tag: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new $gfJaN$restructure.String('length', 'utf16be'), {
type: 'parent',
relativeTo: (ctx)=>ctx.stringOffset
})
});
var $51a9f4feb3a3b2b1$var$NameTable = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
0: {
count: $gfJaN$restructure.uint16,
stringOffset: $gfJaN$restructure.uint16,
records: new $gfJaN$restructure.Array($51a9f4feb3a3b2b1$var$NameRecord, 'count')
},
1: {
count: $gfJaN$restructure.uint16,
stringOffset: $gfJaN$restructure.uint16,
records: new $gfJaN$restructure.Array($51a9f4feb3a3b2b1$var$NameRecord, 'count'),
langTagCount: $gfJaN$restructure.uint16,
langTags: new $gfJaN$restructure.Array($51a9f4feb3a3b2b1$var$LangTagRecord, 'langTagCount')
}
});
var $51a9f4feb3a3b2b1$export$2e2bcd8739ae039 = $51a9f4feb3a3b2b1$var$NameTable;
const $51a9f4feb3a3b2b1$var$NAMES = [
'copyright',
'fontFamily',
'fontSubfamily',
'uniqueSubfamily',
'fullName',
'version',
'postscriptName',
'trademark',
'manufacturer',
'designer',
'description',
'vendorURL',
'designerURL',
'license',
'licenseURL',
null,
'preferredFamily',
'preferredSubfamily',
'compatibleFull',
'sampleText',
'postscriptCIDFontName',
'wwsFamilyName',
'wwsSubfamilyName'
];
$51a9f4feb3a3b2b1$var$NameTable.process = function(stream) {
var records = {};
for (let record of this.records){
// find out what language this is for
let language = (0, $e2613b812f052cbe$export$2092376fd002e13)[record.platformID][record.languageID];
if (language == null && this.langTags != null && record.languageID >= 0x8000) language = this.langTags[record.languageID - 0x8000].tag;
if (language == null) language = record.platformID + '-' + record.languageID;
// if the nameID is >= 256, it is a font feature record (AAT)
let key = record.nameID >= 256 ? 'fontFeatures' : $51a9f4feb3a3b2b1$var$NAMES[record.nameID] || record.nameID;
if (records[key] == null) records[key] = {};
let obj = records[key];
if (record.nameID >= 256) obj = obj[record.nameID] || (obj[record.nameID] = {});
if (typeof record.string === 'string' || typeof obj[language] !== 'string') obj[language] = record.string;
}
this.records = records;
};
$51a9f4feb3a3b2b1$var$NameTable.preEncode = function() {
if (Array.isArray(this.records)) return;
this.version = 0;
let records = [];
for(let key in this.records){
let val = this.records[key];
if (key === 'fontFeatures') continue;
records.push({
platformID: 3,
encodingID: 1,
languageID: 0x409,
nameID: $51a9f4feb3a3b2b1$var$NAMES.indexOf(key),
length: val.en.length * 2,
string: val.en
});
if (key === 'postscriptName') records.push({
platformID: 1,
encodingID: 0,
languageID: 0,
nameID: $51a9f4feb3a3b2b1$var$NAMES.indexOf(key),
length: val.en.length,
string: val.en
});
}
this.records = records;
this.count = records.length;
this.stringOffset = $51a9f4feb3a3b2b1$var$NameTable.size(this, null, false);
};
var $114ea85db469b435$var$OS2 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
header: {
xAvgCharWidth: $gfJaN$restructure.int16,
usWeightClass: $gfJaN$restructure.uint16,
usWidthClass: $gfJaN$restructure.uint16,
fsType: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint16, [
null,
'noEmbedding',
'viewOnly',
'editable',
null,
null,
null,
null,
'noSubsetting',
'bitmapOnly'
]),
ySubscriptXSize: $gfJaN$restructure.int16,
ySubscriptYSize: $gfJaN$restructure.int16,
ySubscriptXOffset: $gfJaN$restructure.int16,
ySubscriptYOffset: $gfJaN$restructure.int16,
ySuperscriptXSize: $gfJaN$restructure.int16,
ySuperscriptYSize: $gfJaN$restructure.int16,
ySuperscriptXOffset: $gfJaN$restructure.int16,
ySuperscriptYOffset: $gfJaN$restructure.int16,
yStrikeoutSize: $gfJaN$restructure.int16,
yStrikeoutPosition: $gfJaN$restructure.int16,
sFamilyClass: $gfJaN$restructure.int16,
panose: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, 10),
ulCharRange: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, 4),
vendorID: new $gfJaN$restructure.String(4),
fsSelection: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint16, [
'italic',
'underscore',
'negative',
'outlined',
'strikeout',
'bold',
'regular',
'useTypoMetrics',
'wws',
'oblique'
]),
usFirstCharIndex: $gfJaN$restructure.uint16,
usLastCharIndex: $gfJaN$restructure.uint16 // The maximum Unicode index in this font
},
// The Apple version of this table ends here, but the Microsoft one continues on...
0: {},
1: {
typoAscender: $gfJaN$restructure.int16,
typoDescender: $gfJaN$restructure.int16,
typoLineGap: $gfJaN$restructure.int16,
winAscent: $gfJaN$restructure.uint16,
winDescent: $gfJaN$restructure.uint16,
codePageRange: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, 2)
},
2: {
// these should be common with version 1 somehow
typoAscender: $gfJaN$restructure.int16,
typoDescender: $gfJaN$restructure.int16,
typoLineGap: $gfJaN$restructure.int16,
winAscent: $gfJaN$restructure.uint16,
winDescent: $gfJaN$restructure.uint16,
codePageRange: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, 2),
xHeight: $gfJaN$restructure.int16,
capHeight: $gfJaN$restructure.int16,
defaultChar: $gfJaN$restructure.uint16,
breakChar: $gfJaN$restructure.uint16,
maxContent: $gfJaN$restructure.uint16
},
5: {
typoAscender: $gfJaN$restructure.int16,
typoDescender: $gfJaN$restructure.int16,
typoLineGap: $gfJaN$restructure.int16,
winAscent: $gfJaN$restructure.uint16,
winDescent: $gfJaN$restructure.uint16,
codePageRange: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, 2),
xHeight: $gfJaN$restructure.int16,
capHeight: $gfJaN$restructure.int16,
defaultChar: $gfJaN$restructure.uint16,
breakChar: $gfJaN$restructure.uint16,
maxContent: $gfJaN$restructure.uint16,
usLowerOpticalPointSize: $gfJaN$restructure.uint16,
usUpperOpticalPointSize: $gfJaN$restructure.uint16
}
});
let $114ea85db469b435$var$versions = $114ea85db469b435$var$OS2.versions;
$114ea85db469b435$var$versions[3] = $114ea85db469b435$var$versions[4] = $114ea85db469b435$var$versions[2];
var $114ea85db469b435$export$2e2bcd8739ae039 = $114ea85db469b435$var$OS2;
var // PostScript information
$f93b30299e1ea0f5$export$2e2bcd8739ae039 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.fixed32, {
header: {
italicAngle: $gfJaN$restructure.fixed32,
underlinePosition: $gfJaN$restructure.int16,
underlineThickness: $gfJaN$restructure.int16,
isFixedPitch: $gfJaN$restructure.uint32,
minMemType42: $gfJaN$restructure.uint32,
maxMemType42: $gfJaN$restructure.uint32,
minMemType1: $gfJaN$restructure.uint32,
maxMemType1: $gfJaN$restructure.uint32 // Maximum memory usage when a TrueType font is downloaded as a Type 1 font
},
1: {},
2: {
numberOfGlyphs: $gfJaN$restructure.uint16,
glyphNameIndex: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'numberOfGlyphs'),
names: new $gfJaN$restructure.Array(new $gfJaN$restructure.String($gfJaN$restructure.uint8))
},
2.5: {
numberOfGlyphs: $gfJaN$restructure.uint16,
offsets: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, 'numberOfGlyphs')
},
3: {},
4: {
map: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, (t)=>t.parent.maxp.numGlyphs)
}
});
var // An array of predefined values accessible by instructions
$8fb09b0f473d61a0$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
controlValues: new $gfJaN$restructure.Array($gfJaN$restructure.int16)
});
var // A list of instructions that are executed once when a font is first used.
// These instructions are known as the font program. The main use of this table
// is for the definition of functions that are used in many different glyph programs.
$873d79fea57d3161$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
instructions: new $gfJaN$restructure.Array($gfJaN$restructure.uint8)
});
let $83c4155666d50c37$var$loca = new $gfJaN$restructure.VersionedStruct('head.indexToLocFormat', {
0: {
offsets: new $gfJaN$restructure.Array($gfJaN$restructure.uint16)
},
1: {
offsets: new $gfJaN$restructure.Array($gfJaN$restructure.uint32)
}
});
$83c4155666d50c37$var$loca.process = function() {
if (this.version === 0 && !this._processed) {
for(let i = 0; i < this.offsets.length; i++)this.offsets[i] <<= 1;
this._processed = true;
}
};
$83c4155666d50c37$var$loca.preEncode = function() {
if (this.version === 0 && this._processed !== false) {
for(let i = 0; i < this.offsets.length; i++)this.offsets[i] >>>= 1;
this._processed = false;
}
};
var $83c4155666d50c37$export$2e2bcd8739ae039 = $83c4155666d50c37$var$loca;
var // Set of instructions executed whenever the point size or font transformation change
$b12598db7cdf7042$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
controlValueProgram: new $gfJaN$restructure.Array($gfJaN$restructure.uint8)
});
var // only used for encoding
$7707bdf21a3d89cc$export$2e2bcd8739ae039 = new $gfJaN$restructure.Array(new $gfJaN$restructure.Buffer);
class $9eaea3754914a290$export$2e2bcd8739ae039 {
getCFFVersion(ctx) {
while(ctx && !ctx.hdrSize)ctx = ctx.parent;
return ctx ? ctx.version : -1;
}
decode(stream, parent) {
let version = this.getCFFVersion(parent);
let count = version >= 2 ? stream.readUInt32BE() : stream.readUInt16BE();
if (count === 0) return [];
let offSize = stream.readUInt8();
let offsetType;
if (offSize === 1) offsetType = $gfJaN$restructure.uint8;
else if (offSize === 2) offsetType = $gfJaN$restructure.uint16;
else if (offSize === 3) offsetType = $gfJaN$restructure.uint24;
else if (offSize === 4) offsetType = $gfJaN$restructure.uint32;
else throw new Error(`Bad offset size in CFFIndex: ${offSize} ${stream.pos}`);
let ret = [];
let startPos = stream.pos + (count + 1) * offSize - 1;
let start = offsetType.decode(stream);
for(let i = 0; i < count; i++){
let end = offsetType.decode(stream);
if (this.type != null) {
let pos = stream.pos;
stream.pos = startPos + start;
parent.length = end - start;
ret.push(this.type.decode(stream, parent));
stream.pos = pos;
} else ret.push({
offset: startPos + start,
length: end - start
});
start = end;
}
stream.pos = startPos + start;
return ret;
}
size(arr, parent) {
let size = 2;
if (arr.length === 0) return size;
let type = this.type || new $gfJaN$restructure.Buffer;
// find maximum offset to detminine offset type
let offset = 1;
for(let i = 0; i < arr.length; i++){
let item = arr[i];
offset += type.size(item, parent);
}
let offsetType;
if (offset <= 0xff) offsetType = $gfJaN$restructure.uint8;
else if (offset <= 0xffff) offsetType = $gfJaN$restructure.uint16;
else if (offset <= 0xffffff) offsetType = $gfJaN$restructure.uint24;
else if (offset <= 0xffffffff) offsetType = $gfJaN$restructure.uint32;
else throw new Error("Bad offset in CFFIndex");
size += 1 + offsetType.size() * (arr.length + 1);
size += offset - 1;
return size;
}
encode(stream, arr, parent) {
stream.writeUInt16BE(arr.length);
if (arr.length === 0) return;
let type = this.type || new $gfJaN$restructure.Buffer;
// find maximum offset to detminine offset type
let sizes = [];
let offset = 1;
for (let item of arr){
let s = type.size(item, parent);
sizes.push(s);
offset += s;
}
let offsetType;
if (offset <= 0xff) offsetType = $gfJaN$restructure.uint8;
else if (offset <= 0xffff) offsetType = $gfJaN$restructure.uint16;
else if (offset <= 0xffffff) offsetType = $gfJaN$restructure.uint24;
else if (offset <= 0xffffffff) offsetType = $gfJaN$restructure.uint32;
else throw new Error("Bad offset in CFFIndex");
// write offset size
stream.writeUInt8(offsetType.size());
// write elements
offset = 1;
offsetType.encode(stream, offset);
for (let size of sizes){
offset += size;
offsetType.encode(stream, offset);
}
for (let item of arr)type.encode(stream, item, parent);
return;
}
constructor(type){
this.type = type;
}
}
const $f77b592c17132d70$var$FLOAT_EOF = 0xf;
const $f77b592c17132d70$var$FLOAT_LOOKUP = [
'0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
'.',
'E',
'E-',
null,
'-'
];
const $f77b592c17132d70$var$FLOAT_ENCODE_LOOKUP = {
'.': 10,
'E': 11,
'E-': 12,
'-': 14
};
class $f77b592c17132d70$export$2e2bcd8739ae039 {
static decode(stream, value) {
if (32 <= value && value <= 246) return value - 139;
if (247 <= value && value <= 250) return (value - 247) * 256 + stream.readUInt8() + 108;
if (251 <= value && value <= 254) return -(value - 251) * 256 - stream.readUInt8() - 108;
if (value === 28) return stream.readInt16BE();
if (value === 29) return stream.readInt32BE();
if (value === 30) {
let str = '';
while(true){
let b = stream.readUInt8();
let n1 = b >> 4;
if (n1 === $f77b592c17132d70$var$FLOAT_EOF) break;
str += $f77b592c17132d70$var$FLOAT_LOOKUP[n1];
let n2 = b & 15;
if (n2 === $f77b592c17132d70$var$FLOAT_EOF) break;
str += $f77b592c17132d70$var$FLOAT_LOOKUP[n2];
}
return parseFloat(str);
}
return null;
}
static size(value) {
// if the value needs to be forced to the largest size (32 bit)
// e.g. for unknown pointers, set to 32768
if (value.forceLarge) value = 32768;
if ((value | 0) !== value) {
let str = '' + value;
return 1 + Math.ceil((str.length + 1) / 2);
} else if (-107 <= value && value <= 107) return 1;
else if (108 <= value && value <= 1131 || -1131 <= value && value <= -108) return 2;
else if (-32768 <= value && value <= 32767) return 3;
else return 5;
}
static encode(stream, value) {
// if the value needs to be forced to the largest size (32 bit)
// e.g. for unknown pointers, save the old value and set to 32768
let val = Number(value);
if (value.forceLarge) {
stream.writeUInt8(29);
return stream.writeInt32BE(val);
} else if ((val | 0) !== val) {
stream.writeUInt8(30);
let str = '' + val;
for(let i = 0; i < str.length; i += 2){
let c1 = str[i];
let n1 = $f77b592c17132d70$var$FLOAT_ENCODE_LOOKUP[c1] || +c1;
if (i === str.length - 1) var n2 = $f77b592c17132d70$var$FLOAT_EOF;
else {
let c2 = str[i + 1];
var n2 = $f77b592c17132d70$var$FLOAT_ENCODE_LOOKUP[c2] || +c2;
}
stream.writeUInt8(n1 << 4 | n2 & 15);
}
if (n2 !== $f77b592c17132d70$var$FLOAT_EOF) return stream.writeUInt8($f77b592c17132d70$var$FLOAT_EOF << 4);
} else if (-107 <= val && val <= 107) return stream.writeUInt8(val + 139);
else if (108 <= val && val <= 1131) {
val -= 108;
stream.writeUInt8((val >> 8) + 247);
return stream.writeUInt8(val & 0xff);
} else if (-1131 <= val && val <= -108) {
val = -val - 108;
stream.writeUInt8((val >> 8) + 251);
return stream.writeUInt8(val & 0xff);
} else if (-32768 <= val && val <= 32767) {
stream.writeUInt8(28);
return stream.writeInt16BE(val);
} else {
stream.writeUInt8(29);
return stream.writeInt32BE(val);
}
}
}
class $efe622f40a9c35bd$export$2e2bcd8739ae039 {
decodeOperands(type, stream, ret, operands) {
if (Array.isArray(type)) return operands.map((op, i)=>this.decodeOperands(type[i], stream, ret, [
op
]));
else if (type.decode != null) return type.decode(stream, ret, operands);
else switch(type){
case 'number':
case 'offset':
case 'sid':
return operands[0];
case 'boolean':
return !!operands[0];
default:
return operands;
}
}
encodeOperands(type, stream, ctx, operands) {
if (Array.isArray(type)) return operands.map((op, i)=>this.encodeOperands(type[i], stream, ctx, op)[0]);
else if (type.encode != null) return type.encode(stream, operands, ctx);
else if (typeof operands === 'number') return [
operands
];
else if (typeof operands === 'boolean') return [
+operands
];
else if (Array.isArray(operands)) return operands;
else return [
operands
];
}
decode(stream, parent) {
let end = stream.pos + parent.length;
let ret = {};
let operands = [];
// define hidden properties
Object.defineProperties(ret, {
parent: {
value: parent
},
_startOffset: {
value: stream.pos
}
});
// fill in defaults
for(let key in this.fields){
let field = this.fields[key];
ret[field[1]] = field[3];
}
while(stream.pos < end){
let b = stream.readUInt8();
if (b < 28) {
if (b === 12) b = b << 8 | stream.readUInt8();
let field = this.fields[b];
if (!field) throw new Error(`Unknown operator ${b}`);
let val = this.decodeOperands(field[2], stream, ret, operands);
if (val != null) {
if (val instanceof (0, $gfJaN$restructure.PropertyDescriptor)) Object.defineProperty(ret, field[1], val);
else ret[field[1]] = val;
}
operands = [];
} else operands.push((0, $f77b592c17132d70$export$2e2bcd8739ae039).decode(stream, b));
}
return ret;
}
size(dict, parent, includePointers = true) {
let ctx = {
parent: parent,
val: dict,
pointerSize: 0,
startOffset: parent.startOffset || 0
};
let len = 0;
for(let k in this.fields){
let field = this.fields[k];
let val = dict[field[1]];
if (val == null || (0, ($parcel$interopDefault($gfJaN$fastdeepequal)))(val, field[3])) continue;
let operands = this.encodeOperands(field[2], null, ctx, val);
for (let op of operands)len += (0, $f77b592c17132d70$export$2e2bcd8739ae039).size(op);
let key = Array.isArray(field[0]) ? field[0] : [
field[0]
];
len += key.length;
}
if (includePointers) len += ctx.pointerSize;
return len;
}
encode(stream, dict, parent) {
let ctx = {
pointers: [],
startOffset: stream.pos,
parent: parent,
val: dict,
pointerSize: 0
};
ctx.pointerOffset = stream.pos + this.size(dict, ctx, false);
for (let field of this.ops){
let val = dict[field[1]];
if (val == null || (0, ($parcel$interopDefault($gfJaN$fastdeepequal)))(val, field[3])) continue;
let operands = this.encodeOperands(field[2], stream, ctx, val);
for (let op of operands)(0, $f77b592c17132d70$export$2e2bcd8739ae039).encode(stream, op);
let key = Array.isArray(field[0]) ? field[0] : [
field[0]
];
for (let op of key)stream.writeUInt8(op);
}
let i = 0;
while(i < ctx.pointers.length){
let ptr = ctx.pointers[i++];
ptr.type.encode(stream, ptr.val, ptr.parent);
}
return;
}
constructor(ops = []){
this.ops = ops;
this.fields = {};
for (let field of ops){
let key = Array.isArray(field[0]) ? field[0][0] << 8 | field[0][1] : field[0];
this.fields[key] = field;
}
}
}
class $4aa1b0749c2770f8$export$2e2bcd8739ae039 extends $gfJaN$restructure.Pointer {
decode(stream, parent, operands) {
this.offsetType = {
decode: ()=>operands[0]
};
return super.decode(stream, parent, operands);
}
encode(stream, value, ctx) {
if (!stream) {
// compute the size (so ctx.pointerSize is correct)
this.offsetType = {
size: ()=>0
};
this.size(value, ctx);
return [
new $4aa1b0749c2770f8$var$Ptr(0)
];
}
let ptr = null;
this.offsetType = {
encode: (stream, val)=>ptr = val
};
super.encode(stream, value, ctx);
return [
new $4aa1b0749c2770f8$var$Ptr(ptr)
];
}
constructor(type, options = {}){
if (options.type == null) options.type = 'global';
super(null, type, options);
}
}
class $4aa1b0749c2770f8$var$Ptr {
valueOf() {
return this.val;
}
constructor(val){
this.val = val;
this.forceLarge = true;
}
}
class $15a0cbb3d09cf7ee$var$CFFBlendOp {
static decode(stream, parent, operands) {
let numBlends = operands.pop();
// TODO: actually blend. For now just consume the deltas
// since we don't use any of the values anyway.
while(operands.length > numBlends)operands.pop();
}
}
var $15a0cbb3d09cf7ee$export$2e2bcd8739ae039 = new (0, $efe622f40a9c35bd$export$2e2bcd8739ae039)([
// key name type default
[
6,
'BlueValues',
'delta',
null
],
[
7,
'OtherBlues',
'delta',
null
],
[
8,
'FamilyBlues',
'delta',
null
],
[
9,
'FamilyOtherBlues',
'delta',
null
],
[
[
12,
9
],
'BlueScale',
'number',
0.039625
],
[
[
12,
10
],
'BlueShift',
'number',
7
],
[
[
12,
11
],
'BlueFuzz',
'number',
1
],
[
10,
'StdHW',
'number',
null
],
[
11,
'StdVW',
'number',
null
],
[
[
12,
12
],
'StemSnapH',
'delta',
null
],
[
[
12,
13
],
'StemSnapV',
'delta',
null
],
[
[
12,
14
],
'ForceBold',
'boolean',
false
],
[
[
12,
17
],
'LanguageGroup',
'number',
0
],
[
[
12,
18
],
'ExpansionFactor',
'number',
0.06
],
[
[
12,
19
],
'initialRandomSeed',
'number',
0
],
[
20,
'defaultWidthX',
'number',
0
],
[
21,
'nominalWidthX',
'number',
0
],
[
22,
'vsindex',
'number',
0
],
[
23,
'blend',
$15a0cbb3d09cf7ee$var$CFFBlendOp,
null
],
[
19,
'Subrs',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)(new (0, $9eaea3754914a290$export$2e2bcd8739ae039), {
type: 'local'
}),
null
]
]);
// Automatically generated from Appendix A of the CFF specification; do
// not edit. Length should be 391.
var $860d3574d7fa3a51$export$2e2bcd8739ae039 = [
".notdef",
"space",
"exclam",
"quotedbl",
"numbersign",
"dollar",
"percent",
"ampersand",
"quoteright",
"parenleft",
"parenright",
"asterisk",
"plus",
"comma",
"hyphen",
"period",
"slash",
"zero",
"one",
"two",
"three",
"four",
"five",
"six",
"seven",
"eight",
"nine",
"colon",
"semicolon",
"less",
"equal",
"greater",
"question",
"at",
"A",
"B",
"C",
"D",
"E",
"F",
"G",
"H",
"I",
"J",
"K",
"L",
"M",
"N",
"O",
"P",
"Q",
"R",
"S",
"T",
"U",
"V",
"W",
"X",
"Y",
"Z",
"bracketleft",
"backslash",
"bracketright",
"asciicircum",
"underscore",
"quoteleft",
"a",
"b",
"c",
"d",
"e",
"f",
"g",
"h",
"i",
"j",
"k",
"l",
"m",
"n",
"o",
"p",
"q",
"r",
"s",
"t",
"u",
"v",
"w",
"x",
"y",
"z",
"braceleft",
"bar",
"braceright",
"asciitilde",
"exclamdown",
"cent",
"sterling",
"fraction",
"yen",
"florin",
"section",
"currency",
"quotesingle",
"quotedblleft",
"guillemotleft",
"guilsinglleft",
"guilsinglright",
"fi",
"fl",
"endash",
"dagger",
"daggerdbl",
"periodcentered",
"paragraph",
"bullet",
"quotesinglbase",
"quotedblbase",
"quotedblright",
"guillemotright",
"ellipsis",
"perthousand",
"questiondown",
"grave",
"acute",
"circumflex",
"tilde",
"macron",
"breve",
"dotaccent",
"dieresis",
"ring",
"cedilla",
"hungarumlaut",
"ogonek",
"caron",
"emdash",
"AE",
"ordfeminine",
"Lslash",
"Oslash",
"OE",
"ordmasculine",
"ae",
"dotlessi",
"lslash",
"oslash",
"oe",
"germandbls",
"onesuperior",
"logicalnot",
"mu",
"trademark",
"Eth",
"onehalf",
"plusminus",
"Thorn",
"onequarter",
"divide",
"brokenbar",
"degree",
"thorn",
"threequarters",
"twosuperior",
"registered",
"minus",
"eth",
"multiply",
"threesuperior",
"copyright",
"Aacute",
"Acircumflex",
"Adieresis",
"Agrave",
"Aring",
"Atilde",
"Ccedilla",
"Eacute",
"Ecircumflex",
"Edieresis",
"Egrave",
"Iacute",
"Icircumflex",
"Idieresis",
"Igrave",
"Ntilde",
"Oacute",
"Ocircumflex",
"Odieresis",
"Ograve",
"Otilde",
"Scaron",
"Uacute",
"Ucircumflex",
"Udieresis",
"Ugrave",
"Yacute",
"Ydieresis",
"Zcaron",
"aacute",
"acircumflex",
"adieresis",
"agrave",
"aring",
"atilde",
"ccedilla",
"eacute",
"ecircumflex",
"edieresis",
"egrave",
"iacute",
"icircumflex",
"idieresis",
"igrave",
"ntilde",
"oacute",
"ocircumflex",
"odieresis",
"ograve",
"otilde",
"scaron",
"uacute",
"ucircumflex",
"udieresis",
"ugrave",
"yacute",
"ydieresis",
"zcaron",
"exclamsmall",
"Hungarumlautsmall",
"dollaroldstyle",
"dollarsuperior",
"ampersandsmall",
"Acutesmall",
"parenleftsuperior",
"parenrightsuperior",
"twodotenleader",
"onedotenleader",
"zerooldstyle",
"oneoldstyle",
"twooldstyle",
"threeoldstyle",
"fouroldstyle",
"fiveoldstyle",
"sixoldstyle",
"sevenoldstyle",
"eightoldstyle",
"nineoldstyle",
"commasuperior",
"threequartersemdash",
"periodsuperior",
"questionsmall",
"asuperior",
"bsuperior",
"centsuperior",
"dsuperior",
"esuperior",
"isuperior",
"lsuperior",
"msuperior",
"nsuperior",
"osuperior",
"rsuperior",
"ssuperior",
"tsuperior",
"ff",
"ffi",
"ffl",
"parenleftinferior",
"parenrightinferior",
"Circumflexsmall",
"hyphensuperior",
"Gravesmall",
"Asmall",
"Bsmall",
"Csmall",
"Dsmall",
"Esmall",
"Fsmall",
"Gsmall",
"Hsmall",
"Ismall",
"Jsmall",
"Ksmall",
"Lsmall",
"Msmall",
"Nsmall",
"Osmall",
"Psmall",
"Qsmall",
"Rsmall",
"Ssmall",
"Tsmall",
"Usmall",
"Vsmall",
"Wsmall",
"Xsmall",
"Ysmall",
"Zsmall",
"colonmonetary",
"onefitted",
"rupiah",
"Tildesmall",
"exclamdownsmall",
"centoldstyle",
"Lslashsmall",
"Scaronsmall",
"Zcaronsmall",
"Dieresissmall",
"Brevesmall",
"Caronsmall",
"Dotaccentsmall",
"Macronsmall",
"figuredash",
"hypheninferior",
"Ogoneksmall",
"Ringsmall",
"Cedillasmall",
"questiondownsmall",
"oneeighth",
"threeeighths",
"fiveeighths",
"seveneighths",
"onethird",
"twothirds",
"zerosuperior",
"foursuperior",
"fivesuperior",
"sixsuperior",
"sevensuperior",
"eightsuperior",
"ninesuperior",
"zeroinferior",
"oneinferior",
"twoinferior",
"threeinferior",
"fourinferior",
"fiveinferior",
"sixinferior",
"seveninferior",
"eightinferior",
"nineinferior",
"centinferior",
"dollarinferior",
"periodinferior",
"commainferior",
"Agravesmall",
"Aacutesmall",
"Acircumflexsmall",
"Atildesmall",
"Adieresissmall",
"Aringsmall",
"AEsmall",
"Ccedillasmall",
"Egravesmall",
"Eacutesmall",
"Ecircumflexsmall",
"Edieresissmall",
"Igravesmall",
"Iacutesmall",
"Icircumflexsmall",
"Idieresissmall",
"Ethsmall",
"Ntildesmall",
"Ogravesmall",
"Oacutesmall",
"Ocircumflexsmall",
"Otildesmall",
"Odieresissmall",
"OEsmall",
"Oslashsmall",
"Ugravesmall",
"Uacutesmall",
"Ucircumflexsmall",
"Udieresissmall",
"Yacutesmall",
"Thornsmall",
"Ydieresissmall",
"001.000",
"001.001",
"001.002",
"001.003",
"Black",
"Bold",
"Book",
"Light",
"Medium",
"Regular",
"Roman",
"Semibold"
];
let $c4ffe47cba1d7f36$export$dee0027060fa13bd = [
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'space',
'exclam',
'quotedbl',
'numbersign',
'dollar',
'percent',
'ampersand',
'quoteright',
'parenleft',
'parenright',
'asterisk',
'plus',
'comma',
'hyphen',
'period',
'slash',
'zero',
'one',
'two',
'three',
'four',
'five',
'six',
'seven',
'eight',
'nine',
'colon',
'semicolon',
'less',
'equal',
'greater',
'question',
'at',
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'H',
'I',
'J',
'K',
'L',
'M',
'N',
'O',
'P',
'Q',
'R',
'S',
'T',
'U',
'V',
'W',
'X',
'Y',
'Z',
'bracketleft',
'backslash',
'bracketright',
'asciicircum',
'underscore',
'quoteleft',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'braceleft',
'bar',
'braceright',
'asciitilde',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'exclamdown',
'cent',
'sterling',
'fraction',
'yen',
'florin',
'section',
'currency',
'quotesingle',
'quotedblleft',
'guillemotleft',
'guilsinglleft',
'guilsinglright',
'fi',
'fl',
'',
'endash',
'dagger',
'daggerdbl',
'periodcentered',
'',
'paragraph',
'bullet',
'quotesinglbase',
'quotedblbase',
'quotedblright',
'guillemotright',
'ellipsis',
'perthousand',
'',
'questiondown',
'',
'grave',
'acute',
'circumflex',
'tilde',
'macron',
'breve',
'dotaccent',
'dieresis',
'',
'ring',
'cedilla',
'',
'hungarumlaut',
'ogonek',
'caron',
'emdash',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'AE',
'',
'ordfeminine',
'',
'',
'',
'',
'Lslash',
'Oslash',
'OE',
'ordmasculine',
'',
'',
'',
'',
'',
'ae',
'',
'',
'',
'dotlessi',
'',
'',
'lslash',
'oslash',
'oe',
'germandbls'
];
let $c4ffe47cba1d7f36$export$4f58f497e14a53c3 = [
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'space',
'exclamsmall',
'Hungarumlautsmall',
'',
'dollaroldstyle',
'dollarsuperior',
'ampersandsmall',
'Acutesmall',
'parenleftsuperior',
'parenrightsuperior',
'twodotenleader',
'onedotenleader',
'comma',
'hyphen',
'period',
'fraction',
'zerooldstyle',
'oneoldstyle',
'twooldstyle',
'threeoldstyle',
'fouroldstyle',
'fiveoldstyle',
'sixoldstyle',
'sevenoldstyle',
'eightoldstyle',
'nineoldstyle',
'colon',
'semicolon',
'commasuperior',
'threequartersemdash',
'periodsuperior',
'questionsmall',
'',
'asuperior',
'bsuperior',
'centsuperior',
'dsuperior',
'esuperior',
'',
'',
'isuperior',
'',
'',
'lsuperior',
'msuperior',
'nsuperior',
'osuperior',
'',
'',
'rsuperior',
'ssuperior',
'tsuperior',
'',
'ff',
'fi',
'fl',
'ffi',
'ffl',
'parenleftinferior',
'',
'parenrightinferior',
'Circumflexsmall',
'hyphensuperior',
'Gravesmall',
'Asmall',
'Bsmall',
'Csmall',
'Dsmall',
'Esmall',
'Fsmall',
'Gsmall',
'Hsmall',
'Ismall',
'Jsmall',
'Ksmall',
'Lsmall',
'Msmall',
'Nsmall',
'Osmall',
'Psmall',
'Qsmall',
'Rsmall',
'Ssmall',
'Tsmall',
'Usmall',
'Vsmall',
'Wsmall',
'Xsmall',
'Ysmall',
'Zsmall',
'colonmonetary',
'onefitted',
'rupiah',
'Tildesmall',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'',
'exclamdownsmall',
'centoldstyle',
'Lslashsmall',
'',
'',
'Scaronsmall',
'Zcaronsmall',
'Dieresissmall',
'Brevesmall',
'Caronsmall',
'',
'Dotaccentsmall',
'',
'',
'Macronsmall',
'',
'',
'figuredash',
'hypheninferior',
'',
'',
'Ogoneksmall',
'Ringsmall',
'Cedillasmall',
'',
'',
'',
'onequarter',
'onehalf',
'threequarters',
'questiondownsmall',
'oneeighth',
'threeeighths',
'fiveeighths',
'seveneighths',
'onethird',
'twothirds',
'',
'',
'zerosuperior',
'onesuperior',
'twosuperior',
'threesuperior',
'foursuperior',
'fivesuperior',
'sixsuperior',
'sevensuperior',
'eightsuperior',
'ninesuperior',
'zeroinferior',
'oneinferior',
'twoinferior',
'threeinferior',
'fourinferior',
'fiveinferior',
'sixinferior',
'seveninferior',
'eightinferior',
'nineinferior',
'centinferior',
'dollarinferior',
'periodinferior',
'commainferior',
'Agravesmall',
'Aacutesmall',
'Acircumflexsmall',
'Atildesmall',
'Adieresissmall',
'Aringsmall',
'AEsmall',
'Ccedillasmall',
'Egravesmall',
'Eacutesmall',
'Ecircumflexsmall',
'Edieresissmall',
'Igravesmall',
'Iacutesmall',
'Icircumflexsmall',
'Idieresissmall',
'Ethsmall',
'Ntildesmall',
'Ogravesmall',
'Oacutesmall',
'Ocircumflexsmall',
'Otildesmall',
'Odieresissmall',
'OEsmall',
'Oslashsmall',
'Ugravesmall',
'Uacutesmall',
'Ucircumflexsmall',
'Udieresissmall',
'Yacutesmall',
'Thornsmall',
'Ydieresissmall'
];
let $1e7c7c16984e4427$export$c33b50336c234f16 = [
'.notdef',
'space',
'exclam',
'quotedbl',
'numbersign',
'dollar',
'percent',
'ampersand',
'quoteright',
'parenleft',
'parenright',
'asterisk',
'plus',
'comma',
'hyphen',
'period',
'slash',
'zero',
'one',
'two',
'three',
'four',
'five',
'six',
'seven',
'eight',
'nine',
'colon',
'semicolon',
'less',
'equal',
'greater',
'question',
'at',
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'H',
'I',
'J',
'K',
'L',
'M',
'N',
'O',
'P',
'Q',
'R',
'S',
'T',
'U',
'V',
'W',
'X',
'Y',
'Z',
'bracketleft',
'backslash',
'bracketright',
'asciicircum',
'underscore',
'quoteleft',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'braceleft',
'bar',
'braceright',
'asciitilde',
'exclamdown',
'cent',
'sterling',
'fraction',
'yen',
'florin',
'section',
'currency',
'quotesingle',
'quotedblleft',
'guillemotleft',
'guilsinglleft',
'guilsinglright',
'fi',
'fl',
'endash',
'dagger',
'daggerdbl',
'periodcentered',
'paragraph',
'bullet',
'quotesinglbase',
'quotedblbase',
'quotedblright',
'guillemotright',
'ellipsis',
'perthousand',
'questiondown',
'grave',
'acute',
'circumflex',
'tilde',
'macron',
'breve',
'dotaccent',
'dieresis',
'ring',
'cedilla',
'hungarumlaut',
'ogonek',
'caron',
'emdash',
'AE',
'ordfeminine',
'Lslash',
'Oslash',
'OE',
'ordmasculine',
'ae',
'dotlessi',
'lslash',
'oslash',
'oe',
'germandbls',
'onesuperior',
'logicalnot',
'mu',
'trademark',
'Eth',
'onehalf',
'plusminus',
'Thorn',
'onequarter',
'divide',
'brokenbar',
'degree',
'thorn',
'threequarters',
'twosuperior',
'registered',
'minus',
'eth',
'multiply',
'threesuperior',
'copyright',
'Aacute',
'Acircumflex',
'Adieresis',
'Agrave',
'Aring',
'Atilde',
'Ccedilla',
'Eacute',
'Ecircumflex',
'Edieresis',
'Egrave',
'Iacute',
'Icircumflex',
'Idieresis',
'Igrave',
'Ntilde',
'Oacute',
'Ocircumflex',
'Odieresis',
'Ograve',
'Otilde',
'Scaron',
'Uacute',
'Ucircumflex',
'Udieresis',
'Ugrave',
'Yacute',
'Ydieresis',
'Zcaron',
'aacute',
'acircumflex',
'adieresis',
'agrave',
'aring',
'atilde',
'ccedilla',
'eacute',
'ecircumflex',
'edieresis',
'egrave',
'iacute',
'icircumflex',
'idieresis',
'igrave',
'ntilde',
'oacute',
'ocircumflex',
'odieresis',
'ograve',
'otilde',
'scaron',
'uacute',
'ucircumflex',
'udieresis',
'ugrave',
'yacute',
'ydieresis',
'zcaron'
];
let $1e7c7c16984e4427$export$3ed0f9e1fee8d489 = [
'.notdef',
'space',
'exclamsmall',
'Hungarumlautsmall',
'dollaroldstyle',
'dollarsuperior',
'ampersandsmall',
'Acutesmall',
'parenleftsuperior',
'parenrightsuperior',
'twodotenleader',
'onedotenleader',
'comma',
'hyphen',
'period',
'fraction',
'zerooldstyle',
'oneoldstyle',
'twooldstyle',
'threeoldstyle',
'fouroldstyle',
'fiveoldstyle',
'sixoldstyle',
'sevenoldstyle',
'eightoldstyle',
'nineoldstyle',
'colon',
'semicolon',
'commasuperior',
'threequartersemdash',
'periodsuperior',
'questionsmall',
'asuperior',
'bsuperior',
'centsuperior',
'dsuperior',
'esuperior',
'isuperior',
'lsuperior',
'msuperior',
'nsuperior',
'osuperior',
'rsuperior',
'ssuperior',
'tsuperior',
'ff',
'fi',
'fl',
'ffi',
'ffl',
'parenleftinferior',
'parenrightinferior',
'Circumflexsmall',
'hyphensuperior',
'Gravesmall',
'Asmall',
'Bsmall',
'Csmall',
'Dsmall',
'Esmall',
'Fsmall',
'Gsmall',
'Hsmall',
'Ismall',
'Jsmall',
'Ksmall',
'Lsmall',
'Msmall',
'Nsmall',
'Osmall',
'Psmall',
'Qsmall',
'Rsmall',
'Ssmall',
'Tsmall',
'Usmall',
'Vsmall',
'Wsmall',
'Xsmall',
'Ysmall',
'Zsmall',
'colonmonetary',
'onefitted',
'rupiah',
'Tildesmall',
'exclamdownsmall',
'centoldstyle',
'Lslashsmall',
'Scaronsmall',
'Zcaronsmall',
'Dieresissmall',
'Brevesmall',
'Caronsmall',
'Dotaccentsmall',
'Macronsmall',
'figuredash',
'hypheninferior',
'Ogoneksmall',
'Ringsmall',
'Cedillasmall',
'onequarter',
'onehalf',
'threequarters',
'questiondownsmall',
'oneeighth',
'threeeighths',
'fiveeighths',
'seveneighths',
'onethird',
'twothirds',
'zerosuperior',
'onesuperior',
'twosuperior',
'threesuperior',
'foursuperior',
'fivesuperior',
'sixsuperior',
'sevensuperior',
'eightsuperior',
'ninesuperior',
'zeroinferior',
'oneinferior',
'twoinferior',
'threeinferior',
'fourinferior',
'fiveinferior',
'sixinferior',
'seveninferior',
'eightinferior',
'nineinferior',
'centinferior',
'dollarinferior',
'periodinferior',
'commainferior',
'Agravesmall',
'Aacutesmall',
'Acircumflexsmall',
'Atildesmall',
'Adieresissmall',
'Aringsmall',
'AEsmall',
'Ccedillasmall',
'Egravesmall',
'Eacutesmall',
'Ecircumflexsmall',
'Edieresissmall',
'Igravesmall',
'Iacutesmall',
'Icircumflexsmall',
'Idieresissmall',
'Ethsmall',
'Ntildesmall',
'Ogravesmall',
'Oacutesmall',
'Ocircumflexsmall',
'Otildesmall',
'Odieresissmall',
'OEsmall',
'Oslashsmall',
'Ugravesmall',
'Uacutesmall',
'Ucircumflexsmall',
'Udieresissmall',
'Yacutesmall',
'Thornsmall',
'Ydieresissmall'
];
let $1e7c7c16984e4427$export$dc28be11139d4120 = [
'.notdef',
'space',
'dollaroldstyle',
'dollarsuperior',
'parenleftsuperior',
'parenrightsuperior',
'twodotenleader',
'onedotenleader',
'comma',
'hyphen',
'period',
'fraction',
'zerooldstyle',
'oneoldstyle',
'twooldstyle',
'threeoldstyle',
'fouroldstyle',
'fiveoldstyle',
'sixoldstyle',
'sevenoldstyle',
'eightoldstyle',
'nineoldstyle',
'colon',
'semicolon',
'commasuperior',
'threequartersemdash',
'periodsuperior',
'asuperior',
'bsuperior',
'centsuperior',
'dsuperior',
'esuperior',
'isuperior',
'lsuperior',
'msuperior',
'nsuperior',
'osuperior',
'rsuperior',
'ssuperior',
'tsuperior',
'ff',
'fi',
'fl',
'ffi',
'ffl',
'parenleftinferior',
'parenrightinferior',
'hyphensuperior',
'colonmonetary',
'onefitted',
'rupiah',
'centoldstyle',
'figuredash',
'hypheninferior',
'onequarter',
'onehalf',
'threequarters',
'oneeighth',
'threeeighths',
'fiveeighths',
'seveneighths',
'onethird',
'twothirds',
'zerosuperior',
'onesuperior',
'twosuperior',
'threesuperior',
'foursuperior',
'fivesuperior',
'sixsuperior',
'sevensuperior',
'eightsuperior',
'ninesuperior',
'zeroinferior',
'oneinferior',
'twoinferior',
'threeinferior',
'fourinferior',
'fiveinferior',
'sixinferior',
'seveninferior',
'eightinferior',
'nineinferior',
'centinferior',
'dollarinferior',
'periodinferior',
'commainferior'
];
//########################
// Scripts and Languages #
//########################
let $b6dd765146ad212a$var$LangSysTable = new $gfJaN$restructure.Struct({
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
reqFeatureIndex: $gfJaN$restructure.uint16,
featureCount: $gfJaN$restructure.uint16,
featureIndexes: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'featureCount')
});
let $b6dd765146ad212a$var$LangSysRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
langSys: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$LangSysTable, {
type: 'parent'
})
});
let $b6dd765146ad212a$var$Script = new $gfJaN$restructure.Struct({
defaultLangSys: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$LangSysTable),
count: $gfJaN$restructure.uint16,
langSysRecords: new $gfJaN$restructure.Array($b6dd765146ad212a$var$LangSysRecord, 'count')
});
let $b6dd765146ad212a$var$ScriptRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
script: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$Script, {
type: 'parent'
})
});
let $b6dd765146ad212a$export$3e15fc05ce864229 = new $gfJaN$restructure.Array($b6dd765146ad212a$var$ScriptRecord, $gfJaN$restructure.uint16);
//#######################
// Features and Lookups #
//#######################
let $b6dd765146ad212a$var$FeatureParams = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
nameID: $gfJaN$restructure.uint16
});
let $b6dd765146ad212a$export$6e91cf7616333d5 = new $gfJaN$restructure.Struct({
featureParams: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$FeatureParams),
lookupCount: $gfJaN$restructure.uint16,
lookupListIndexes: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'lookupCount')
});
let $b6dd765146ad212a$var$FeatureRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
feature: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$6e91cf7616333d5, {
type: 'parent'
})
});
let $b6dd765146ad212a$export$aa18130def4b6cb4 = new $gfJaN$restructure.Array($b6dd765146ad212a$var$FeatureRecord, $gfJaN$restructure.uint16);
let $b6dd765146ad212a$var$LookupFlags = new $gfJaN$restructure.Struct({
markAttachmentType: $gfJaN$restructure.uint8,
flags: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint8, [
'rightToLeft',
'ignoreBaseGlyphs',
'ignoreLigatures',
'ignoreMarks',
'useMarkFilteringSet'
])
});
function $b6dd765146ad212a$export$df0008c6ff2da22a(SubTable) {
let Lookup = new $gfJaN$restructure.Struct({
lookupType: $gfJaN$restructure.uint16,
flags: $b6dd765146ad212a$var$LookupFlags,
subTableCount: $gfJaN$restructure.uint16,
subTables: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, SubTable), 'subTableCount'),
markFilteringSet: new $gfJaN$restructure.Optional($gfJaN$restructure.uint16, (t)=>t.flags.flags.useMarkFilteringSet)
});
return new $gfJaN$restructure.LazyArray(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, Lookup), $gfJaN$restructure.uint16);
}
//#################
// Coverage Table #
//#################
let $b6dd765146ad212a$var$RangeRecord = new $gfJaN$restructure.Struct({
start: $gfJaN$restructure.uint16,
end: $gfJaN$restructure.uint16,
startCoverageIndex: $gfJaN$restructure.uint16
});
let $b6dd765146ad212a$export$17608c3f81a6111 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
glyphCount: $gfJaN$restructure.uint16,
glyphs: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'glyphCount')
},
2: {
rangeCount: $gfJaN$restructure.uint16,
rangeRecords: new $gfJaN$restructure.Array($b6dd765146ad212a$var$RangeRecord, 'rangeCount')
}
});
//#########################
// Class Definition Table #
//#########################
let $b6dd765146ad212a$var$ClassRangeRecord = new $gfJaN$restructure.Struct({
start: $gfJaN$restructure.uint16,
end: $gfJaN$restructure.uint16,
class: $gfJaN$restructure.uint16
});
let $b6dd765146ad212a$export$843d551fbbafef71 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
startGlyph: $gfJaN$restructure.uint16,
glyphCount: $gfJaN$restructure.uint16,
classValueArray: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'glyphCount')
},
2: {
classRangeCount: $gfJaN$restructure.uint16,
classRangeRecord: new $gfJaN$restructure.Array($b6dd765146ad212a$var$ClassRangeRecord, 'classRangeCount')
}
});
let $b6dd765146ad212a$export$8215d14a63d9fb10 = new $gfJaN$restructure.Struct({
a: $gfJaN$restructure.uint16,
b: $gfJaN$restructure.uint16,
deltaFormat: $gfJaN$restructure.uint16
});
//#############################################
// Contextual Substitution/Positioning Tables #
//#############################################
let $b6dd765146ad212a$var$LookupRecord = new $gfJaN$restructure.Struct({
sequenceIndex: $gfJaN$restructure.uint16,
lookupListIndex: $gfJaN$restructure.uint16
});
let $b6dd765146ad212a$var$Rule = new $gfJaN$restructure.Struct({
glyphCount: $gfJaN$restructure.uint16,
lookupCount: $gfJaN$restructure.uint16,
input: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, (t)=>t.glyphCount - 1),
lookupRecords: new $gfJaN$restructure.Array($b6dd765146ad212a$var$LookupRecord, 'lookupCount')
});
let $b6dd765146ad212a$var$RuleSet = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$Rule), $gfJaN$restructure.uint16);
let $b6dd765146ad212a$var$ClassRule = new $gfJaN$restructure.Struct({
glyphCount: $gfJaN$restructure.uint16,
lookupCount: $gfJaN$restructure.uint16,
classes: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, (t)=>t.glyphCount - 1),
lookupRecords: new $gfJaN$restructure.Array($b6dd765146ad212a$var$LookupRecord, 'lookupCount')
});
let $b6dd765146ad212a$var$ClassSet = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$ClassRule), $gfJaN$restructure.uint16);
let $b6dd765146ad212a$export$841858b892ce1f4c = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111),
ruleSetCount: $gfJaN$restructure.uint16,
ruleSets: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$RuleSet), 'ruleSetCount')
},
2: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111),
classDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$843d551fbbafef71),
classSetCnt: $gfJaN$restructure.uint16,
classSet: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$ClassSet), 'classSetCnt')
},
3: {
glyphCount: $gfJaN$restructure.uint16,
lookupCount: $gfJaN$restructure.uint16,
coverages: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111), 'glyphCount'),
lookupRecords: new $gfJaN$restructure.Array($b6dd765146ad212a$var$LookupRecord, 'lookupCount')
}
});
//######################################################
// Chaining Contextual Substitution/Positioning Tables #
//######################################################
let $b6dd765146ad212a$var$ChainRule = new $gfJaN$restructure.Struct({
backtrackGlyphCount: $gfJaN$restructure.uint16,
backtrack: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'backtrackGlyphCount'),
inputGlyphCount: $gfJaN$restructure.uint16,
input: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, (t)=>t.inputGlyphCount - 1),
lookaheadGlyphCount: $gfJaN$restructure.uint16,
lookahead: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'lookaheadGlyphCount'),
lookupCount: $gfJaN$restructure.uint16,
lookupRecords: new $gfJaN$restructure.Array($b6dd765146ad212a$var$LookupRecord, 'lookupCount')
});
let $b6dd765146ad212a$var$ChainRuleSet = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$ChainRule), $gfJaN$restructure.uint16);
let $b6dd765146ad212a$export$5e6d09e6861162f6 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111),
chainCount: $gfJaN$restructure.uint16,
chainRuleSets: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$ChainRuleSet), 'chainCount')
},
2: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111),
backtrackClassDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$843d551fbbafef71),
inputClassDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$843d551fbbafef71),
lookaheadClassDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$843d551fbbafef71),
chainCount: $gfJaN$restructure.uint16,
chainClassSet: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$var$ChainRuleSet), 'chainCount')
},
3: {
backtrackGlyphCount: $gfJaN$restructure.uint16,
backtrackCoverage: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111), 'backtrackGlyphCount'),
inputGlyphCount: $gfJaN$restructure.uint16,
inputCoverage: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111), 'inputGlyphCount'),
lookaheadGlyphCount: $gfJaN$restructure.uint16,
lookaheadCoverage: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b6dd765146ad212a$export$17608c3f81a6111), 'lookaheadGlyphCount'),
lookupCount: $gfJaN$restructure.uint16,
lookupRecords: new $gfJaN$restructure.Array($b6dd765146ad212a$var$LookupRecord, 'lookupCount')
}
});
/*******************
* Variation Store *
*******************/ let $2e4adcda047b3383$var$F2DOT14 = new $gfJaN$restructure.Fixed(16, 'BE', 14);
let $2e4adcda047b3383$var$RegionAxisCoordinates = new $gfJaN$restructure.Struct({
startCoord: $2e4adcda047b3383$var$F2DOT14,
peakCoord: $2e4adcda047b3383$var$F2DOT14,
endCoord: $2e4adcda047b3383$var$F2DOT14
});
let $2e4adcda047b3383$var$VariationRegionList = new $gfJaN$restructure.Struct({
axisCount: $gfJaN$restructure.uint16,
regionCount: $gfJaN$restructure.uint16,
variationRegions: new $gfJaN$restructure.Array(new $gfJaN$restructure.Array($2e4adcda047b3383$var$RegionAxisCoordinates, 'axisCount'), 'regionCount')
});
let $2e4adcda047b3383$var$DeltaSet = new $gfJaN$restructure.Struct({
shortDeltas: new $gfJaN$restructure.Array($gfJaN$restructure.int16, (t)=>t.parent.shortDeltaCount),
regionDeltas: new $gfJaN$restructure.Array($gfJaN$restructure.int8, (t)=>t.parent.regionIndexCount - t.parent.shortDeltaCount),
deltas: (t)=>t.shortDeltas.concat(t.regionDeltas)
});
let $2e4adcda047b3383$var$ItemVariationData = new $gfJaN$restructure.Struct({
itemCount: $gfJaN$restructure.uint16,
shortDeltaCount: $gfJaN$restructure.uint16,
regionIndexCount: $gfJaN$restructure.uint16,
regionIndexes: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'regionIndexCount'),
deltaSets: new $gfJaN$restructure.Array($2e4adcda047b3383$var$DeltaSet, 'itemCount')
});
let $2e4adcda047b3383$export$fe1b122a2710f241 = new $gfJaN$restructure.Struct({
format: $gfJaN$restructure.uint16,
variationRegionList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $2e4adcda047b3383$var$VariationRegionList),
variationDataCount: $gfJaN$restructure.uint16,
itemVariationData: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $2e4adcda047b3383$var$ItemVariationData), 'variationDataCount')
});
/**********************
* Feature Variations *
**********************/ let $2e4adcda047b3383$var$ConditionTable = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
axisIndex: $gfJaN$restructure.uint16,
axisIndex: $gfJaN$restructure.uint16,
filterRangeMinValue: $2e4adcda047b3383$var$F2DOT14,
filterRangeMaxValue: $2e4adcda047b3383$var$F2DOT14
}
});
let $2e4adcda047b3383$var$ConditionSet = new $gfJaN$restructure.Struct({
conditionCount: $gfJaN$restructure.uint16,
conditionTable: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $2e4adcda047b3383$var$ConditionTable), 'conditionCount')
});
let $2e4adcda047b3383$var$FeatureTableSubstitutionRecord = new $gfJaN$restructure.Struct({
featureIndex: $gfJaN$restructure.uint16,
alternateFeatureTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, (0, $b6dd765146ad212a$export$6e91cf7616333d5), {
type: 'parent'
})
});
let $2e4adcda047b3383$var$FeatureTableSubstitution = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.fixed32,
substitutionCount: $gfJaN$restructure.uint16,
substitutions: new $gfJaN$restructure.Array($2e4adcda047b3383$var$FeatureTableSubstitutionRecord, 'substitutionCount')
});
let $2e4adcda047b3383$var$FeatureVariationRecord = new $gfJaN$restructure.Struct({
conditionSet: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $2e4adcda047b3383$var$ConditionSet, {
type: 'parent'
}),
featureTableSubstitution: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $2e4adcda047b3383$var$FeatureTableSubstitution, {
type: 'parent'
})
});
let $2e4adcda047b3383$export$441b70b7971dd419 = new $gfJaN$restructure.Struct({
majorVersion: $gfJaN$restructure.uint16,
minorVersion: $gfJaN$restructure.uint16,
featureVariationRecordCount: $gfJaN$restructure.uint32,
featureVariationRecords: new $gfJaN$restructure.Array($2e4adcda047b3383$var$FeatureVariationRecord, 'featureVariationRecordCount')
});
// Checks if an operand is an index of a predefined value,
// otherwise delegates to the provided type.
class $5b547cf9e5da519b$var$PredefinedOp {
decode(stream, parent, operands) {
if (this.predefinedOps[operands[0]]) return this.predefinedOps[operands[0]];
return this.type.decode(stream, parent, operands);
}
size(value, ctx) {
return this.type.size(value, ctx);
}
encode(stream, value, ctx) {
let index = this.predefinedOps.indexOf(value);
if (index !== -1) return index;
return this.type.encode(stream, value, ctx);
}
constructor(predefinedOps, type){
this.predefinedOps = predefinedOps;
this.type = type;
}
}
class $5b547cf9e5da519b$var$CFFEncodingVersion extends $gfJaN$restructure.Number {
decode(stream) {
return $gfJaN$restructure.uint8.decode(stream) & 0x7f;
}
constructor(){
super('UInt8');
}
}
let $5b547cf9e5da519b$var$Range1 = new $gfJaN$restructure.Struct({
first: $gfJaN$restructure.uint16,
nLeft: $gfJaN$restructure.uint8
});
let $5b547cf9e5da519b$var$Range2 = new $gfJaN$restructure.Struct({
first: $gfJaN$restructure.uint16,
nLeft: $gfJaN$restructure.uint16
});
let $5b547cf9e5da519b$var$CFFCustomEncoding = new $gfJaN$restructure.VersionedStruct(new $5b547cf9e5da519b$var$CFFEncodingVersion(), {
0: {
nCodes: $gfJaN$restructure.uint8,
codes: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, 'nCodes')
},
1: {
nRanges: $gfJaN$restructure.uint8,
ranges: new $gfJaN$restructure.Array($5b547cf9e5da519b$var$Range1, 'nRanges')
}
});
let $5b547cf9e5da519b$var$CFFEncoding = new $5b547cf9e5da519b$var$PredefinedOp([
(0, $c4ffe47cba1d7f36$export$dee0027060fa13bd),
(0, $c4ffe47cba1d7f36$export$4f58f497e14a53c3)
], new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$CFFCustomEncoding, {
lazy: true
}));
// Decodes an array of ranges until the total
// length is equal to the provided length.
class $5b547cf9e5da519b$var$RangeArray extends $gfJaN$restructure.Array {
decode(stream, parent) {
let length = (0, $gfJaN$restructure.resolveLength)(this.length, stream, parent);
let count = 0;
let res = [];
while(count < length){
let range = this.type.decode(stream, parent);
range.offset = count;
count += range.nLeft + 1;
res.push(range);
}
return res;
}
}
let $5b547cf9e5da519b$var$CFFCustomCharset = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint8, {
0: {
glyphs: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, (t)=>t.parent.CharStrings.length - 1)
},
1: {
ranges: new $5b547cf9e5da519b$var$RangeArray($5b547cf9e5da519b$var$Range1, (t)=>t.parent.CharStrings.length - 1)
},
2: {
ranges: new $5b547cf9e5da519b$var$RangeArray($5b547cf9e5da519b$var$Range2, (t)=>t.parent.CharStrings.length - 1)
}
});
let $5b547cf9e5da519b$var$CFFCharset = new $5b547cf9e5da519b$var$PredefinedOp([
(0, $1e7c7c16984e4427$export$c33b50336c234f16),
(0, $1e7c7c16984e4427$export$3ed0f9e1fee8d489),
(0, $1e7c7c16984e4427$export$dc28be11139d4120)
], new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$CFFCustomCharset, {
lazy: true
}));
let $5b547cf9e5da519b$var$FDRange3 = new $gfJaN$restructure.Struct({
first: $gfJaN$restructure.uint16,
fd: $gfJaN$restructure.uint8
});
let $5b547cf9e5da519b$var$FDRange4 = new $gfJaN$restructure.Struct({
first: $gfJaN$restructure.uint32,
fd: $gfJaN$restructure.uint16
});
let $5b547cf9e5da519b$var$FDSelect = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint8, {
0: {
fds: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, (t)=>t.parent.CharStrings.length)
},
3: {
nRanges: $gfJaN$restructure.uint16,
ranges: new $gfJaN$restructure.Array($5b547cf9e5da519b$var$FDRange3, 'nRanges'),
sentinel: $gfJaN$restructure.uint16
},
4: {
nRanges: $gfJaN$restructure.uint32,
ranges: new $gfJaN$restructure.Array($5b547cf9e5da519b$var$FDRange4, 'nRanges'),
sentinel: $gfJaN$restructure.uint32
}
});
let $5b547cf9e5da519b$var$ptr = new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)((0, $15a0cbb3d09cf7ee$export$2e2bcd8739ae039));
class $5b547cf9e5da519b$var$CFFPrivateOp {
decode(stream, parent, operands) {
parent.length = operands[0];
return $5b547cf9e5da519b$var$ptr.decode(stream, parent, [
operands[1]
]);
}
size(dict, ctx) {
return [
(0, $15a0cbb3d09cf7ee$export$2e2bcd8739ae039).size(dict, ctx, false),
$5b547cf9e5da519b$var$ptr.size(dict, ctx)[0]
];
}
encode(stream, dict, ctx) {
return [
(0, $15a0cbb3d09cf7ee$export$2e2bcd8739ae039).size(dict, ctx, false),
$5b547cf9e5da519b$var$ptr.encode(stream, dict, ctx)[0]
];
}
}
let $5b547cf9e5da519b$var$FontDict = new (0, $efe622f40a9c35bd$export$2e2bcd8739ae039)([
// key name type(s) default
[
18,
'Private',
new $5b547cf9e5da519b$var$CFFPrivateOp,
null
],
[
[
12,
38
],
'FontName',
'sid',
null
],
[
[
12,
7
],
'FontMatrix',
'array',
[
0.001,
0,
0,
0.001,
0,
0
]
],
[
[
12,
5
],
'PaintType',
'number',
0
]
]);
let $5b547cf9e5da519b$var$CFFTopDict = new (0, $efe622f40a9c35bd$export$2e2bcd8739ae039)([
// key name type(s) default
[
[
12,
30
],
'ROS',
[
'sid',
'sid',
'number'
],
null
],
[
0,
'version',
'sid',
null
],
[
1,
'Notice',
'sid',
null
],
[
[
12,
0
],
'Copyright',
'sid',
null
],
[
2,
'FullName',
'sid',
null
],
[
3,
'FamilyName',
'sid',
null
],
[
4,
'Weight',
'sid',
null
],
[
[
12,
1
],
'isFixedPitch',
'boolean',
false
],
[
[
12,
2
],
'ItalicAngle',
'number',
0
],
[
[
12,
3
],
'UnderlinePosition',
'number',
-100
],
[
[
12,
4
],
'UnderlineThickness',
'number',
50
],
[
[
12,
5
],
'PaintType',
'number',
0
],
[
[
12,
6
],
'CharstringType',
'number',
2
],
[
[
12,
7
],
'FontMatrix',
'array',
[
0.001,
0,
0,
0.001,
0,
0
]
],
[
13,
'UniqueID',
'number',
null
],
[
5,
'FontBBox',
'array',
[
0,
0,
0,
0
]
],
[
[
12,
8
],
'StrokeWidth',
'number',
0
],
[
14,
'XUID',
'array',
null
],
[
15,
'charset',
$5b547cf9e5da519b$var$CFFCharset,
(0, $1e7c7c16984e4427$export$c33b50336c234f16)
],
[
16,
'Encoding',
$5b547cf9e5da519b$var$CFFEncoding,
(0, $c4ffe47cba1d7f36$export$dee0027060fa13bd)
],
[
17,
'CharStrings',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)(new (0, $9eaea3754914a290$export$2e2bcd8739ae039)),
null
],
[
18,
'Private',
new $5b547cf9e5da519b$var$CFFPrivateOp,
null
],
[
[
12,
20
],
'SyntheticBase',
'number',
null
],
[
[
12,
21
],
'PostScript',
'sid',
null
],
[
[
12,
22
],
'BaseFontName',
'sid',
null
],
[
[
12,
23
],
'BaseFontBlend',
'delta',
null
],
// CID font specific
[
[
12,
31
],
'CIDFontVersion',
'number',
0
],
[
[
12,
32
],
'CIDFontRevision',
'number',
0
],
[
[
12,
33
],
'CIDFontType',
'number',
0
],
[
[
12,
34
],
'CIDCount',
'number',
8720
],
[
[
12,
35
],
'UIDBase',
'number',
null
],
[
[
12,
37
],
'FDSelect',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$FDSelect),
null
],
[
[
12,
36
],
'FDArray',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)(new (0, $9eaea3754914a290$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$FontDict)),
null
],
[
[
12,
38
],
'FontName',
'sid',
null
]
]);
let $5b547cf9e5da519b$var$VariationStore = new $gfJaN$restructure.Struct({
length: $gfJaN$restructure.uint16,
itemVariationStore: (0, $2e4adcda047b3383$export$fe1b122a2710f241)
});
let $5b547cf9e5da519b$var$CFF2TopDict = new (0, $efe622f40a9c35bd$export$2e2bcd8739ae039)([
[
[
12,
7
],
'FontMatrix',
'array',
[
0.001,
0,
0,
0.001,
0,
0
]
],
[
17,
'CharStrings',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)(new (0, $9eaea3754914a290$export$2e2bcd8739ae039)),
null
],
[
[
12,
37
],
'FDSelect',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$FDSelect),
null
],
[
[
12,
36
],
'FDArray',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)(new (0, $9eaea3754914a290$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$FontDict)),
null
],
[
24,
'vstore',
new (0, $4aa1b0749c2770f8$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$VariationStore),
null
],
[
25,
'maxstack',
'number',
193
]
]);
let $5b547cf9e5da519b$var$CFFTop = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.fixed16, {
1: {
hdrSize: $gfJaN$restructure.uint8,
offSize: $gfJaN$restructure.uint8,
nameIndex: new (0, $9eaea3754914a290$export$2e2bcd8739ae039)(new $gfJaN$restructure.String('length')),
topDictIndex: new (0, $9eaea3754914a290$export$2e2bcd8739ae039)($5b547cf9e5da519b$var$CFFTopDict),
stringIndex: new (0, $9eaea3754914a290$export$2e2bcd8739ae039)(new $gfJaN$restructure.String('length')),
globalSubrIndex: new (0, $9eaea3754914a290$export$2e2bcd8739ae039)
},
2: {
hdrSize: $gfJaN$restructure.uint8,
length: $gfJaN$restructure.uint16,
topDict: $5b547cf9e5da519b$var$CFF2TopDict,
globalSubrIndex: new (0, $9eaea3754914a290$export$2e2bcd8739ae039)
}
});
var $5b547cf9e5da519b$export$2e2bcd8739ae039 = $5b547cf9e5da519b$var$CFFTop;
class $f717432b360040c7$var$CFFFont {
static decode(stream) {
return new $f717432b360040c7$var$CFFFont(stream);
}
decode() {
let start = this.stream.pos;
let top = (0, $5b547cf9e5da519b$export$2e2bcd8739ae039).decode(this.stream);
for(let key in top){
let val = top[key];
this[key] = val;
}
if (this.version < 2) {
if (this.topDictIndex.length !== 1) throw new Error("Only a single font is allowed in CFF");
this.topDict = this.topDictIndex[0];
}
this.isCIDFont = this.topDict.ROS != null;
return this;
}
string(sid) {
if (this.version >= 2) return null;
if (sid < (0, $860d3574d7fa3a51$export$2e2bcd8739ae039).length) return (0, $860d3574d7fa3a51$export$2e2bcd8739ae039)[sid];
return this.stringIndex[sid - (0, $860d3574d7fa3a51$export$2e2bcd8739ae039).length];
}
get postscriptName() {
if (this.version < 2) return this.nameIndex[0];
return null;
}
get fullName() {
return this.string(this.topDict.FullName);
}
get familyName() {
return this.string(this.topDict.FamilyName);
}
getCharString(glyph) {
this.stream.pos = this.topDict.CharStrings[glyph].offset;
return this.stream.readBuffer(this.topDict.CharStrings[glyph].length);
}
getGlyphName(gid) {
// CFF2 glyph names are in the post table.
if (this.version >= 2) return null;
// CID-keyed fonts don't have glyph names
if (this.isCIDFont) return null;
let { charset: charset } = this.topDict;
if (Array.isArray(charset)) return charset[gid];
if (gid === 0) return '.notdef';
gid -= 1;
switch(charset.version){
case 0:
return this.string(charset.glyphs[gid]);
case 1:
case 2:
for(let i = 0; i < charset.ranges.length; i++){
let range = charset.ranges[i];
if (range.offset <= gid && gid <= range.offset + range.nLeft) return this.string(range.first + (gid - range.offset));
}
break;
}
return null;
}
fdForGlyph(gid) {
if (!this.topDict.FDSelect) return null;
switch(this.topDict.FDSelect.version){
case 0:
return this.topDict.FDSelect.fds[gid];
case 3:
case 4:
let { ranges: ranges } = this.topDict.FDSelect;
let low = 0;
let high = ranges.length - 1;
while(low <= high){
let mid = low + high >> 1;
if (gid < ranges[mid].first) high = mid - 1;
else if (mid < high && gid >= ranges[mid + 1].first) low = mid + 1;
else return ranges[mid].fd;
}
default:
throw new Error(`Unknown FDSelect version: ${this.topDict.FDSelect.version}`);
}
}
privateDictForGlyph(gid) {
if (this.topDict.FDSelect) {
let fd = this.fdForGlyph(gid);
if (this.topDict.FDArray[fd]) return this.topDict.FDArray[fd].Private;
return null;
}
if (this.version < 2) return this.topDict.Private;
return this.topDict.FDArray[0].Private;
}
constructor(stream){
this.stream = stream;
this.decode();
}
}
var $f717432b360040c7$export$2e2bcd8739ae039 = $f717432b360040c7$var$CFFFont;
let $8cb7ae73ed7aa7d8$var$VerticalOrigin = new $gfJaN$restructure.Struct({
glyphIndex: $gfJaN$restructure.uint16,
vertOriginY: $gfJaN$restructure.int16
});
var $8cb7ae73ed7aa7d8$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
majorVersion: $gfJaN$restructure.uint16,
minorVersion: $gfJaN$restructure.uint16,
defaultVertOriginY: $gfJaN$restructure.int16,
numVertOriginYMetrics: $gfJaN$restructure.uint16,
metrics: new $gfJaN$restructure.Array($8cb7ae73ed7aa7d8$var$VerticalOrigin, 'numVertOriginYMetrics')
});
let $20e0c7bbecb76d75$export$16b227cb15d716a0 = new $gfJaN$restructure.Struct({
height: $gfJaN$restructure.uint8,
width: $gfJaN$restructure.uint8,
horiBearingX: $gfJaN$restructure.int8,
horiBearingY: $gfJaN$restructure.int8,
horiAdvance: $gfJaN$restructure.uint8,
vertBearingX: $gfJaN$restructure.int8,
vertBearingY: $gfJaN$restructure.int8,
vertAdvance: $gfJaN$restructure.uint8
});
let $20e0c7bbecb76d75$export$62c53e75f69bfe12 = new $gfJaN$restructure.Struct({
height: $gfJaN$restructure.uint8,
width: $gfJaN$restructure.uint8,
bearingX: $gfJaN$restructure.int8,
bearingY: $gfJaN$restructure.int8,
advance: $gfJaN$restructure.uint8
});
let $20e0c7bbecb76d75$var$EBDTComponent = new $gfJaN$restructure.Struct({
glyph: $gfJaN$restructure.uint16,
xOffset: $gfJaN$restructure.int8,
yOffset: $gfJaN$restructure.int8
});
class $20e0c7bbecb76d75$var$ByteAligned {
}
class $20e0c7bbecb76d75$var$BitAligned {
}
let $20e0c7bbecb76d75$export$f1f5ddeb20d14f = new $gfJaN$restructure.VersionedStruct('version', {
1: {
metrics: $20e0c7bbecb76d75$export$62c53e75f69bfe12,
data: $20e0c7bbecb76d75$var$ByteAligned
},
2: {
metrics: $20e0c7bbecb76d75$export$62c53e75f69bfe12,
data: $20e0c7bbecb76d75$var$BitAligned
},
// format 3 is deprecated
// format 4 is not supported by Microsoft
5: {
data: $20e0c7bbecb76d75$var$BitAligned
},
6: {
metrics: $20e0c7bbecb76d75$export$16b227cb15d716a0,
data: $20e0c7bbecb76d75$var$ByteAligned
},
7: {
metrics: $20e0c7bbecb76d75$export$16b227cb15d716a0,
data: $20e0c7bbecb76d75$var$BitAligned
},
8: {
metrics: $20e0c7bbecb76d75$export$62c53e75f69bfe12,
pad: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8),
numComponents: $gfJaN$restructure.uint16,
components: new $gfJaN$restructure.Array($20e0c7bbecb76d75$var$EBDTComponent, 'numComponents')
},
9: {
metrics: $20e0c7bbecb76d75$export$16b227cb15d716a0,
pad: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8),
numComponents: $gfJaN$restructure.uint16,
components: new $gfJaN$restructure.Array($20e0c7bbecb76d75$var$EBDTComponent, 'numComponents')
},
17: {
metrics: $20e0c7bbecb76d75$export$62c53e75f69bfe12,
dataLen: $gfJaN$restructure.uint32,
data: new $gfJaN$restructure.Buffer('dataLen')
},
18: {
metrics: $20e0c7bbecb76d75$export$16b227cb15d716a0,
dataLen: $gfJaN$restructure.uint32,
data: new $gfJaN$restructure.Buffer('dataLen')
},
19: {
dataLen: $gfJaN$restructure.uint32,
data: new $gfJaN$restructure.Buffer('dataLen')
}
});
let $035bb95c0cdb1f6d$var$SBitLineMetrics = new $gfJaN$restructure.Struct({
ascender: $gfJaN$restructure.int8,
descender: $gfJaN$restructure.int8,
widthMax: $gfJaN$restructure.uint8,
caretSlopeNumerator: $gfJaN$restructure.int8,
caretSlopeDenominator: $gfJaN$restructure.int8,
caretOffset: $gfJaN$restructure.int8,
minOriginSB: $gfJaN$restructure.int8,
minAdvanceSB: $gfJaN$restructure.int8,
maxBeforeBL: $gfJaN$restructure.int8,
minAfterBL: $gfJaN$restructure.int8,
pad: new $gfJaN$restructure.Reserved($gfJaN$restructure.int8, 2)
});
let $035bb95c0cdb1f6d$var$CodeOffsetPair = new $gfJaN$restructure.Struct({
glyphCode: $gfJaN$restructure.uint16,
offset: $gfJaN$restructure.uint16
});
let $035bb95c0cdb1f6d$var$IndexSubtable = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
header: {
imageFormat: $gfJaN$restructure.uint16,
imageDataOffset: $gfJaN$restructure.uint32
},
1: {
offsetArray: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, (t)=>t.parent.lastGlyphIndex - t.parent.firstGlyphIndex + 1)
},
2: {
imageSize: $gfJaN$restructure.uint32,
bigMetrics: (0, $20e0c7bbecb76d75$export$16b227cb15d716a0)
},
3: {
offsetArray: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, (t)=>t.parent.lastGlyphIndex - t.parent.firstGlyphIndex + 1)
},
4: {
numGlyphs: $gfJaN$restructure.uint32,
glyphArray: new $gfJaN$restructure.Array($035bb95c0cdb1f6d$var$CodeOffsetPair, (t)=>t.numGlyphs + 1)
},
5: {
imageSize: $gfJaN$restructure.uint32,
bigMetrics: (0, $20e0c7bbecb76d75$export$16b227cb15d716a0),
numGlyphs: $gfJaN$restructure.uint32,
glyphCodeArray: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'numGlyphs')
}
});
let $035bb95c0cdb1f6d$var$IndexSubtableArray = new $gfJaN$restructure.Struct({
firstGlyphIndex: $gfJaN$restructure.uint16,
lastGlyphIndex: $gfJaN$restructure.uint16,
subtable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $035bb95c0cdb1f6d$var$IndexSubtable)
});
let $035bb95c0cdb1f6d$var$BitmapSizeTable = new $gfJaN$restructure.Struct({
indexSubTableArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($035bb95c0cdb1f6d$var$IndexSubtableArray, 1), {
type: 'parent'
}),
indexTablesSize: $gfJaN$restructure.uint32,
numberOfIndexSubTables: $gfJaN$restructure.uint32,
colorRef: $gfJaN$restructure.uint32,
hori: $035bb95c0cdb1f6d$var$SBitLineMetrics,
vert: $035bb95c0cdb1f6d$var$SBitLineMetrics,
startGlyphIndex: $gfJaN$restructure.uint16,
endGlyphIndex: $gfJaN$restructure.uint16,
ppemX: $gfJaN$restructure.uint8,
ppemY: $gfJaN$restructure.uint8,
bitDepth: $gfJaN$restructure.uint8,
flags: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint8, [
'horizontal',
'vertical'
])
});
var $035bb95c0cdb1f6d$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint32,
numSizes: $gfJaN$restructure.uint32,
sizes: new $gfJaN$restructure.Array($035bb95c0cdb1f6d$var$BitmapSizeTable, 'numSizes')
});
let $73d13900b55a3c0c$var$ImageTable = new $gfJaN$restructure.Struct({
ppem: $gfJaN$restructure.uint16,
resolution: $gfJaN$restructure.uint16,
imageOffsets: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, 'void'), (t)=>t.parent.parent.maxp.numGlyphs + 1)
});
var // This is the Apple sbix table, used by the "Apple Color Emoji" font.
// It includes several image tables with images for each bitmap glyph
// of several different sizes.
$73d13900b55a3c0c$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
flags: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint16, [
'renderOutlines'
]),
numImgTables: $gfJaN$restructure.uint32,
imageTables: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $73d13900b55a3c0c$var$ImageTable), 'numImgTables')
});
let $97f6b8be3a347a8f$var$LayerRecord = new $gfJaN$restructure.Struct({
gid: $gfJaN$restructure.uint16,
paletteIndex: $gfJaN$restructure.uint16 // Index value to use in the appropriate palette. This value must
}); // be less than numPaletteEntries in the CPAL table, except for
// the special case noted below. Each palette entry is 16 bits.
// A palette index of 0xFFFF is a special case indicating that
// the text foreground color should be used.
let $97f6b8be3a347a8f$var$BaseGlyphRecord = new $gfJaN$restructure.Struct({
gid: $gfJaN$restructure.uint16,
// and is not rendered for color.
firstLayerIndex: $gfJaN$restructure.uint16,
// There will be numLayers consecutive entries for this base glyph.
numLayers: $gfJaN$restructure.uint16
});
var $97f6b8be3a347a8f$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
numBaseGlyphRecords: $gfJaN$restructure.uint16,
baseGlyphRecord: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($97f6b8be3a347a8f$var$BaseGlyphRecord, 'numBaseGlyphRecords')),
layerRecords: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($97f6b8be3a347a8f$var$LayerRecord, 'numLayerRecords'), {
lazy: true
}),
numLayerRecords: $gfJaN$restructure.uint16
});
let $16ca60ecbdee30ea$var$ColorRecord = new $gfJaN$restructure.Struct({
blue: $gfJaN$restructure.uint8,
green: $gfJaN$restructure.uint8,
red: $gfJaN$restructure.uint8,
alpha: $gfJaN$restructure.uint8
});
var $16ca60ecbdee30ea$export$2e2bcd8739ae039 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
header: {
numPaletteEntries: $gfJaN$restructure.uint16,
numPalettes: $gfJaN$restructure.uint16,
numColorRecords: $gfJaN$restructure.uint16,
colorRecords: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($16ca60ecbdee30ea$var$ColorRecord, 'numColorRecords')),
colorRecordIndices: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'numPalettes')
},
0: {},
1: {
offsetPaletteTypeArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($gfJaN$restructure.uint32, 'numPalettes')),
offsetPaletteLabelArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'numPalettes')),
offsetPaletteEntryLabelArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'numPaletteEntries'))
}
});
let $7327e41706f9d5c7$var$BaseCoord = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
coordinate: $gfJaN$restructure.int16 // X or Y value, in design units
},
2: {
coordinate: $gfJaN$restructure.int16,
referenceGlyph: $gfJaN$restructure.uint16,
baseCoordPoint: $gfJaN$restructure.uint16 // Index of contour point on the referenceGlyph
},
3: {
coordinate: $gfJaN$restructure.int16,
deviceTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10)) // Device table for X or Y value
}
});
let $7327e41706f9d5c7$var$BaseValues = new $gfJaN$restructure.Struct({
defaultIndex: $gfJaN$restructure.uint16,
baseCoordCount: $gfJaN$restructure.uint16,
baseCoords: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseCoord), 'baseCoordCount')
});
let $7327e41706f9d5c7$var$FeatMinMaxRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
minCoord: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseCoord, {
type: 'parent'
}),
maxCoord: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseCoord, {
type: 'parent'
}) // May be NULL
});
let $7327e41706f9d5c7$var$MinMax = new $gfJaN$restructure.Struct({
minCoord: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseCoord),
maxCoord: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseCoord),
featMinMaxCount: $gfJaN$restructure.uint16,
featMinMaxRecords: new $gfJaN$restructure.Array($7327e41706f9d5c7$var$FeatMinMaxRecord, 'featMinMaxCount') // In alphabetical order
});
let $7327e41706f9d5c7$var$BaseLangSysRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
minMax: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$MinMax, {
type: 'parent'
})
});
let $7327e41706f9d5c7$var$BaseScript = new $gfJaN$restructure.Struct({
baseValues: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseValues),
defaultMinMax: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$MinMax),
baseLangSysCount: $gfJaN$restructure.uint16,
baseLangSysRecords: new $gfJaN$restructure.Array($7327e41706f9d5c7$var$BaseLangSysRecord, 'baseLangSysCount') // in alphabetical order by BaseLangSysTag
});
let $7327e41706f9d5c7$var$BaseScriptRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
script: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseScript, {
type: 'parent'
})
});
let $7327e41706f9d5c7$var$BaseScriptList = new $gfJaN$restructure.Array($7327e41706f9d5c7$var$BaseScriptRecord, $gfJaN$restructure.uint16);
// Array of 4-byte baseline identification tags-must be in alphabetical order
let $7327e41706f9d5c7$var$BaseTagList = new $gfJaN$restructure.Array(new $gfJaN$restructure.String(4), $gfJaN$restructure.uint16);
let $7327e41706f9d5c7$var$Axis = new $gfJaN$restructure.Struct({
baseTagList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseTagList),
baseScriptList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$BaseScriptList)
});
var $7327e41706f9d5c7$export$2e2bcd8739ae039 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint32, {
header: {
horizAxis: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$Axis),
vertAxis: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7327e41706f9d5c7$var$Axis) // May be NULL
},
0x00010000: {},
0x00010001: {
itemVariationStore: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, (0, $2e4adcda047b3383$export$fe1b122a2710f241))
}
});
let $7e48bbe9e5345664$var$AttachPoint = new $gfJaN$restructure.Array($gfJaN$restructure.uint16, $gfJaN$restructure.uint16);
let $7e48bbe9e5345664$var$AttachList = new $gfJaN$restructure.Struct({
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
glyphCount: $gfJaN$restructure.uint16,
attachPoints: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7e48bbe9e5345664$var$AttachPoint), 'glyphCount')
});
let $7e48bbe9e5345664$var$CaretValue = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
coordinate: $gfJaN$restructure.int16
},
2: {
caretValuePoint: $gfJaN$restructure.uint16
},
3: {
coordinate: $gfJaN$restructure.int16,
deviceTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10))
}
});
let $7e48bbe9e5345664$var$LigGlyph = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7e48bbe9e5345664$var$CaretValue), $gfJaN$restructure.uint16);
let $7e48bbe9e5345664$var$LigCaretList = new $gfJaN$restructure.Struct({
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
ligGlyphCount: $gfJaN$restructure.uint16,
ligGlyphs: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7e48bbe9e5345664$var$LigGlyph), 'ligGlyphCount')
});
let $7e48bbe9e5345664$var$MarkGlyphSetsDef = new $gfJaN$restructure.Struct({
markSetTableFormat: $gfJaN$restructure.uint16,
markSetCount: $gfJaN$restructure.uint16,
coverage: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, (0, $b6dd765146ad212a$export$17608c3f81a6111)), 'markSetCount')
});
var $7e48bbe9e5345664$export$2e2bcd8739ae039 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint32, {
header: {
glyphClassDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$843d551fbbafef71)),
attachList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7e48bbe9e5345664$var$AttachList),
ligCaretList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7e48bbe9e5345664$var$LigCaretList),
markAttachClassDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$843d551fbbafef71))
},
0x00010000: {},
0x00010002: {
markGlyphSetsDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7e48bbe9e5345664$var$MarkGlyphSetsDef)
},
0x00010003: {
markGlyphSetsDef: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $7e48bbe9e5345664$var$MarkGlyphSetsDef),
itemVariationStore: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, (0, $2e4adcda047b3383$export$fe1b122a2710f241))
}
});
let $b687332511a4da75$var$ValueFormat = new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint16, [
'xPlacement',
'yPlacement',
'xAdvance',
'yAdvance',
'xPlaDevice',
'yPlaDevice',
'xAdvDevice',
'yAdvDevice'
]);
let $b687332511a4da75$var$types = {
xPlacement: $gfJaN$restructure.int16,
yPlacement: $gfJaN$restructure.int16,
xAdvance: $gfJaN$restructure.int16,
yAdvance: $gfJaN$restructure.int16,
xPlaDevice: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10), {
type: 'global',
relativeTo: (ctx)=>ctx.rel
}),
yPlaDevice: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10), {
type: 'global',
relativeTo: (ctx)=>ctx.rel
}),
xAdvDevice: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10), {
type: 'global',
relativeTo: (ctx)=>ctx.rel
}),
yAdvDevice: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10), {
type: 'global',
relativeTo: (ctx)=>ctx.rel
})
};
class $b687332511a4da75$var$ValueRecord {
buildStruct(parent) {
let struct = parent;
while(!struct[this.key] && struct.parent)struct = struct.parent;
if (!struct[this.key]) return;
let fields = {};
fields.rel = ()=>struct._startOffset;
let format = struct[this.key];
for(let key in format)if (format[key]) fields[key] = $b687332511a4da75$var$types[key];
return new $gfJaN$restructure.Struct(fields);
}
size(val, ctx) {
return this.buildStruct(ctx).size(val, ctx);
}
decode(stream, parent) {
let res = this.buildStruct(parent).decode(stream, parent);
delete res.rel;
return res;
}
constructor(key = 'valueFormat'){
this.key = key;
}
}
let $b687332511a4da75$var$PairValueRecord = new $gfJaN$restructure.Struct({
secondGlyph: $gfJaN$restructure.uint16,
value1: new $b687332511a4da75$var$ValueRecord('valueFormat1'),
value2: new $b687332511a4da75$var$ValueRecord('valueFormat2')
});
let $b687332511a4da75$var$PairSet = new $gfJaN$restructure.Array($b687332511a4da75$var$PairValueRecord, $gfJaN$restructure.uint16);
let $b687332511a4da75$var$Class2Record = new $gfJaN$restructure.Struct({
value1: new $b687332511a4da75$var$ValueRecord('valueFormat1'),
value2: new $b687332511a4da75$var$ValueRecord('valueFormat2')
});
let $b687332511a4da75$var$Anchor = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
xCoordinate: $gfJaN$restructure.int16,
yCoordinate: $gfJaN$restructure.int16
},
2: {
xCoordinate: $gfJaN$restructure.int16,
yCoordinate: $gfJaN$restructure.int16,
anchorPoint: $gfJaN$restructure.uint16
},
3: {
xCoordinate: $gfJaN$restructure.int16,
yCoordinate: $gfJaN$restructure.int16,
xDeviceTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10)),
yDeviceTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$8215d14a63d9fb10))
}
});
let $b687332511a4da75$var$EntryExitRecord = new $gfJaN$restructure.Struct({
entryAnchor: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$Anchor, {
type: 'parent'
}),
exitAnchor: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$Anchor, {
type: 'parent'
})
});
let $b687332511a4da75$var$MarkRecord = new $gfJaN$restructure.Struct({
class: $gfJaN$restructure.uint16,
markAnchor: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$Anchor, {
type: 'parent'
})
});
let $b687332511a4da75$var$MarkArray = new $gfJaN$restructure.Array($b687332511a4da75$var$MarkRecord, $gfJaN$restructure.uint16);
let $b687332511a4da75$var$BaseRecord = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$Anchor), (t)=>t.parent.classCount);
let $b687332511a4da75$var$BaseArray = new $gfJaN$restructure.Array($b687332511a4da75$var$BaseRecord, $gfJaN$restructure.uint16);
let $b687332511a4da75$var$ComponentRecord = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$Anchor), (t)=>t.parent.parent.classCount);
let $b687332511a4da75$var$LigatureAttach = new $gfJaN$restructure.Array($b687332511a4da75$var$ComponentRecord, $gfJaN$restructure.uint16);
let $b687332511a4da75$var$LigatureArray = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$LigatureAttach), $gfJaN$restructure.uint16);
let $b687332511a4da75$export$73a8cfb19cd43a0f = new $gfJaN$restructure.VersionedStruct('lookupType', {
1: new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
valueFormat: $b687332511a4da75$var$ValueFormat,
value: new $b687332511a4da75$var$ValueRecord()
},
2: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
valueFormat: $b687332511a4da75$var$ValueFormat,
valueCount: $gfJaN$restructure.uint16,
values: new $gfJaN$restructure.LazyArray(new $b687332511a4da75$var$ValueRecord(), 'valueCount')
}
}),
2: new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
valueFormat1: $b687332511a4da75$var$ValueFormat,
valueFormat2: $b687332511a4da75$var$ValueFormat,
pairSetCount: $gfJaN$restructure.uint16,
pairSets: new $gfJaN$restructure.LazyArray(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$PairSet), 'pairSetCount')
},
2: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
valueFormat1: $b687332511a4da75$var$ValueFormat,
valueFormat2: $b687332511a4da75$var$ValueFormat,
classDef1: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$843d551fbbafef71)),
classDef2: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$843d551fbbafef71)),
class1Count: $gfJaN$restructure.uint16,
class2Count: $gfJaN$restructure.uint16,
classRecords: new $gfJaN$restructure.LazyArray(new $gfJaN$restructure.LazyArray($b687332511a4da75$var$Class2Record, 'class2Count'), 'class1Count')
}
}),
3: {
format: $gfJaN$restructure.uint16,
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
entryExitCount: $gfJaN$restructure.uint16,
entryExitRecords: new $gfJaN$restructure.Array($b687332511a4da75$var$EntryExitRecord, 'entryExitCount')
},
4: {
format: $gfJaN$restructure.uint16,
markCoverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
baseCoverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
classCount: $gfJaN$restructure.uint16,
markArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$MarkArray),
baseArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$BaseArray)
},
5: {
format: $gfJaN$restructure.uint16,
markCoverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
ligatureCoverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
classCount: $gfJaN$restructure.uint16,
markArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$MarkArray),
ligatureArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$LigatureArray)
},
6: {
format: $gfJaN$restructure.uint16,
mark1Coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
mark2Coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
classCount: $gfJaN$restructure.uint16,
mark1Array: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$MarkArray),
mark2Array: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $b687332511a4da75$var$BaseArray)
},
7: (0, $b6dd765146ad212a$export$841858b892ce1f4c),
8: (0, $b6dd765146ad212a$export$5e6d09e6861162f6),
9: {
posFormat: $gfJaN$restructure.uint16,
lookupType: $gfJaN$restructure.uint16,
extension: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, null)
}
});
// Fix circular reference
$b687332511a4da75$export$73a8cfb19cd43a0f.versions[9].extension.type = $b687332511a4da75$export$73a8cfb19cd43a0f;
var $b687332511a4da75$export$2e2bcd8739ae039 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint32, {
header: {
scriptList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$3e15fc05ce864229)),
featureList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$aa18130def4b6cb4)),
lookupList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new (0, $b6dd765146ad212a$export$df0008c6ff2da22a)($b687332511a4da75$export$73a8cfb19cd43a0f))
},
0x00010000: {},
0x00010001: {
featureVariations: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, (0, $2e4adcda047b3383$export$441b70b7971dd419))
}
});
let $99ccad60b96f92fb$var$Sequence = new $gfJaN$restructure.Array($gfJaN$restructure.uint16, $gfJaN$restructure.uint16);
let $99ccad60b96f92fb$var$AlternateSet = $99ccad60b96f92fb$var$Sequence;
let $99ccad60b96f92fb$var$Ligature = new $gfJaN$restructure.Struct({
glyph: $gfJaN$restructure.uint16,
compCount: $gfJaN$restructure.uint16,
components: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, (t)=>t.compCount - 1)
});
let $99ccad60b96f92fb$var$LigatureSet = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $99ccad60b96f92fb$var$Ligature), $gfJaN$restructure.uint16);
let $99ccad60b96f92fb$var$GSUBLookup = new $gfJaN$restructure.VersionedStruct('lookupType', {
1: new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
1: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
deltaGlyphID: $gfJaN$restructure.int16
},
2: {
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
glyphCount: $gfJaN$restructure.uint16,
substitute: new $gfJaN$restructure.LazyArray($gfJaN$restructure.uint16, 'glyphCount')
}
}),
2: {
substFormat: $gfJaN$restructure.uint16,
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
count: $gfJaN$restructure.uint16,
sequences: new $gfJaN$restructure.LazyArray(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $99ccad60b96f92fb$var$Sequence), 'count')
},
3: {
substFormat: $gfJaN$restructure.uint16,
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
count: $gfJaN$restructure.uint16,
alternateSet: new $gfJaN$restructure.LazyArray(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $99ccad60b96f92fb$var$AlternateSet), 'count')
},
4: {
substFormat: $gfJaN$restructure.uint16,
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
count: $gfJaN$restructure.uint16,
ligatureSets: new $gfJaN$restructure.LazyArray(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $99ccad60b96f92fb$var$LigatureSet), 'count')
},
5: (0, $b6dd765146ad212a$export$841858b892ce1f4c),
6: (0, $b6dd765146ad212a$export$5e6d09e6861162f6),
7: {
substFormat: $gfJaN$restructure.uint16,
lookupType: $gfJaN$restructure.uint16,
extension: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, null)
},
8: {
substFormat: $gfJaN$restructure.uint16,
coverage: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)),
backtrackCoverage: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)), 'backtrackGlyphCount'),
lookaheadGlyphCount: $gfJaN$restructure.uint16,
lookaheadCoverage: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$17608c3f81a6111)), 'lookaheadGlyphCount'),
glyphCount: $gfJaN$restructure.uint16,
substitutes: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'glyphCount')
}
});
// Fix circular reference
$99ccad60b96f92fb$var$GSUBLookup.versions[7].extension.type = $99ccad60b96f92fb$var$GSUBLookup;
var $99ccad60b96f92fb$export$2e2bcd8739ae039 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint32, {
header: {
scriptList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$3e15fc05ce864229)),
featureList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, (0, $b6dd765146ad212a$export$aa18130def4b6cb4)),
lookupList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new (0, $b6dd765146ad212a$export$df0008c6ff2da22a)($99ccad60b96f92fb$var$GSUBLookup))
},
0x00010000: {},
0x00010001: {
featureVariations: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, (0, $2e4adcda047b3383$export$441b70b7971dd419))
}
});
let $573d5042c76c4940$var$JstfGSUBModList = new $gfJaN$restructure.Array($gfJaN$restructure.uint16, $gfJaN$restructure.uint16);
let $573d5042c76c4940$var$JstfPriority = new $gfJaN$restructure.Struct({
shrinkageEnableGSUB: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
shrinkageDisableGSUB: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
shrinkageEnableGPOS: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
shrinkageDisableGPOS: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
shrinkageJstfMax: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new (0, $b6dd765146ad212a$export$df0008c6ff2da22a)((0, $b687332511a4da75$export$73a8cfb19cd43a0f))),
extensionEnableGSUB: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
extensionDisableGSUB: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
extensionEnableGPOS: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
extensionDisableGPOS: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfGSUBModList),
extensionJstfMax: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new (0, $b6dd765146ad212a$export$df0008c6ff2da22a)((0, $b687332511a4da75$export$73a8cfb19cd43a0f)))
});
let $573d5042c76c4940$var$JstfLangSys = new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfPriority), $gfJaN$restructure.uint16);
let $573d5042c76c4940$var$JstfLangSysRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
jstfLangSys: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfLangSys)
});
let $573d5042c76c4940$var$JstfScript = new $gfJaN$restructure.Struct({
extenderGlyphs: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new $gfJaN$restructure.Array($gfJaN$restructure.uint16, $gfJaN$restructure.uint16)),
defaultLangSys: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfLangSys),
langSysCount: $gfJaN$restructure.uint16,
langSysRecords: new $gfJaN$restructure.Array($573d5042c76c4940$var$JstfLangSysRecord, 'langSysCount')
});
let $573d5042c76c4940$var$JstfScriptRecord = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
script: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $573d5042c76c4940$var$JstfScript, {
type: 'parent'
})
});
var $573d5042c76c4940$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint32,
scriptCount: $gfJaN$restructure.uint16,
scriptList: new $gfJaN$restructure.Array($573d5042c76c4940$var$JstfScriptRecord, 'scriptCount')
});
// TODO: add this to restructure
class $a5875b80d6087f61$var$VariableSizeNumber {
decode(stream, parent) {
switch(this.size(0, parent)){
case 1:
return stream.readUInt8();
case 2:
return stream.readUInt16BE();
case 3:
return stream.readUInt24BE();
case 4:
return stream.readUInt32BE();
}
}
size(val, parent) {
return (0, $gfJaN$restructure.resolveLength)(this._size, null, parent);
}
constructor(size){
this._size = size;
}
}
let $a5875b80d6087f61$var$MapDataEntry = new $gfJaN$restructure.Struct({
entry: new $a5875b80d6087f61$var$VariableSizeNumber((t)=>((t.parent.entryFormat & 0x0030) >> 4) + 1),
outerIndex: (t)=>t.entry >> (t.parent.entryFormat & 0x000F) + 1,
innerIndex: (t)=>t.entry & (1 << (t.parent.entryFormat & 0x000F) + 1) - 1
});
let $a5875b80d6087f61$var$DeltaSetIndexMap = new $gfJaN$restructure.Struct({
entryFormat: $gfJaN$restructure.uint16,
mapCount: $gfJaN$restructure.uint16,
mapData: new $gfJaN$restructure.Array($a5875b80d6087f61$var$MapDataEntry, 'mapCount')
});
var $a5875b80d6087f61$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
majorVersion: $gfJaN$restructure.uint16,
minorVersion: $gfJaN$restructure.uint16,
itemVariationStore: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, (0, $2e4adcda047b3383$export$fe1b122a2710f241)),
advanceWidthMapping: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $a5875b80d6087f61$var$DeltaSetIndexMap),
LSBMapping: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $a5875b80d6087f61$var$DeltaSetIndexMap),
RSBMapping: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $a5875b80d6087f61$var$DeltaSetIndexMap)
});
let $4423bc1ac09bbbd1$var$Signature = new $gfJaN$restructure.Struct({
format: $gfJaN$restructure.uint32,
length: $gfJaN$restructure.uint32,
offset: $gfJaN$restructure.uint32
});
let $4423bc1ac09bbbd1$var$SignatureBlock = new $gfJaN$restructure.Struct({
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16, 2),
cbSignature: $gfJaN$restructure.uint32,
signature: new $gfJaN$restructure.Buffer('cbSignature')
});
var $4423bc1ac09bbbd1$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
ulVersion: $gfJaN$restructure.uint32,
usNumSigs: $gfJaN$restructure.uint16,
usFlag: $gfJaN$restructure.uint16,
signatures: new $gfJaN$restructure.Array($4423bc1ac09bbbd1$var$Signature, 'usNumSigs'),
signatureBlocks: new $gfJaN$restructure.Array($4423bc1ac09bbbd1$var$SignatureBlock, 'usNumSigs')
});
let $7b50e3f8d83263de$var$GaspRange = new $gfJaN$restructure.Struct({
rangeMaxPPEM: $gfJaN$restructure.uint16,
rangeGaspBehavior: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint16, [
'grayscale',
'gridfit',
'symmetricSmoothing',
'symmetricGridfit' // only in version 1, for ClearType
])
});
var $7b50e3f8d83263de$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
numRanges: $gfJaN$restructure.uint16,
gaspRanges: new $gfJaN$restructure.Array($7b50e3f8d83263de$var$GaspRange, 'numRanges') // Sorted by ppem
});
let $7bf92ec372cd2307$var$DeviceRecord = new $gfJaN$restructure.Struct({
pixelSize: $gfJaN$restructure.uint8,
maximumWidth: $gfJaN$restructure.uint8,
widths: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, (t)=>t.parent.parent.maxp.numGlyphs)
});
var // The Horizontal Device Metrics table stores integer advance widths scaled to particular pixel sizes
$7bf92ec372cd2307$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
numRecords: $gfJaN$restructure.int16,
sizeDeviceRecord: $gfJaN$restructure.int32,
records: new $gfJaN$restructure.Array($7bf92ec372cd2307$var$DeviceRecord, 'numRecords')
});
let $a3f544bcf76542d1$var$KernPair = new $gfJaN$restructure.Struct({
left: $gfJaN$restructure.uint16,
right: $gfJaN$restructure.uint16,
value: $gfJaN$restructure.int16
});
let $a3f544bcf76542d1$var$ClassTable = new $gfJaN$restructure.Struct({
firstGlyph: $gfJaN$restructure.uint16,
nGlyphs: $gfJaN$restructure.uint16,
offsets: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'nGlyphs'),
max: (t)=>t.offsets.length && Math.max.apply(Math, t.offsets)
});
let $a3f544bcf76542d1$var$Kern2Array = new $gfJaN$restructure.Struct({
off: (t)=>t._startOffset - t.parent.parent._startOffset,
len: (t)=>((t.parent.leftTable.max - t.off) / t.parent.rowWidth + 1) * (t.parent.rowWidth / 2),
values: new $gfJaN$restructure.LazyArray($gfJaN$restructure.int16, 'len')
});
let $a3f544bcf76542d1$var$KernSubtable = new $gfJaN$restructure.VersionedStruct('format', {
0: {
nPairs: $gfJaN$restructure.uint16,
searchRange: $gfJaN$restructure.uint16,
entrySelector: $gfJaN$restructure.uint16,
rangeShift: $gfJaN$restructure.uint16,
pairs: new $gfJaN$restructure.Array($a3f544bcf76542d1$var$KernPair, 'nPairs')
},
2: {
rowWidth: $gfJaN$restructure.uint16,
leftTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $a3f544bcf76542d1$var$ClassTable, {
type: 'parent'
}),
rightTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $a3f544bcf76542d1$var$ClassTable, {
type: 'parent'
}),
array: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $a3f544bcf76542d1$var$Kern2Array, {
type: 'parent'
})
},
3: {
glyphCount: $gfJaN$restructure.uint16,
kernValueCount: $gfJaN$restructure.uint8,
leftClassCount: $gfJaN$restructure.uint8,
rightClassCount: $gfJaN$restructure.uint8,
flags: $gfJaN$restructure.uint8,
kernValue: new $gfJaN$restructure.Array($gfJaN$restructure.int16, 'kernValueCount'),
leftClass: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, 'glyphCount'),
rightClass: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, 'glyphCount'),
kernIndex: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, (t)=>t.leftClassCount * t.rightClassCount)
}
});
let $a3f544bcf76542d1$var$KernTable = new $gfJaN$restructure.VersionedStruct('version', {
0: {
subVersion: $gfJaN$restructure.uint16,
length: $gfJaN$restructure.uint16,
format: $gfJaN$restructure.uint8,
coverage: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint8, [
'horizontal',
'minimum',
'crossStream',
'override' // If set to 1 the value in this table replaces the accumulated value
]),
subtable: $a3f544bcf76542d1$var$KernSubtable,
padding: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8, (t)=>t.length - t._currentOffset)
},
1: {
length: $gfJaN$restructure.uint32,
coverage: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint8, [
null,
null,
null,
null,
null,
'variation',
'crossStream',
'vertical' // Set if table has vertical kerning values
]),
format: $gfJaN$restructure.uint8,
tupleIndex: $gfJaN$restructure.uint16,
subtable: $a3f544bcf76542d1$var$KernSubtable,
padding: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8, (t)=>t.length - t._currentOffset)
}
});
var $a3f544bcf76542d1$export$2e2bcd8739ae039 = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
0: {
nTables: $gfJaN$restructure.uint16,
tables: new $gfJaN$restructure.Array($a3f544bcf76542d1$var$KernTable, 'nTables')
},
1: {
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
nTables: $gfJaN$restructure.uint32,
tables: new $gfJaN$restructure.Array($a3f544bcf76542d1$var$KernTable, 'nTables')
}
});
var // Linear Threshold table
// Records the ppem for each glyph at which the scaling becomes linear again,
// despite instructions effecting the advance width
$86687befb45925d0$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
numGlyphs: $gfJaN$restructure.uint16,
yPels: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, 'numGlyphs')
});
var // PCL 5 Table
// NOTE: The PCLT table is strongly discouraged for OpenType fonts with TrueType outlines
$91429006e51e0fe8$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
fontNumber: $gfJaN$restructure.uint32,
pitch: $gfJaN$restructure.uint16,
xHeight: $gfJaN$restructure.uint16,
style: $gfJaN$restructure.uint16,
typeFamily: $gfJaN$restructure.uint16,
capHeight: $gfJaN$restructure.uint16,
symbolSet: $gfJaN$restructure.uint16,
typeface: new $gfJaN$restructure.String(16),
characterComplement: new $gfJaN$restructure.String(8),
fileName: new $gfJaN$restructure.String(6),
strokeWeight: new $gfJaN$restructure.String(1),
widthType: new $gfJaN$restructure.String(1),
serifStyle: $gfJaN$restructure.uint8,
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8)
});
// VDMX tables contain ascender/descender overrides for certain (usually small)
// sizes. This is needed in order to match font metrics on Windows.
let $627850fc9deed59a$var$Ratio = new $gfJaN$restructure.Struct({
bCharSet: $gfJaN$restructure.uint8,
xRatio: $gfJaN$restructure.uint8,
yStartRatio: $gfJaN$restructure.uint8,
yEndRatio: $gfJaN$restructure.uint8 // Ending y-Ratio value
});
let $627850fc9deed59a$var$vTable = new $gfJaN$restructure.Struct({
yPelHeight: $gfJaN$restructure.uint16,
yMax: $gfJaN$restructure.int16,
yMin: $gfJaN$restructure.int16 // Minimum value (in pels) for this yPelHeight
});
let $627850fc9deed59a$var$VdmxGroup = new $gfJaN$restructure.Struct({
recs: $gfJaN$restructure.uint16,
startsz: $gfJaN$restructure.uint8,
endsz: $gfJaN$restructure.uint8,
entries: new $gfJaN$restructure.Array($627850fc9deed59a$var$vTable, 'recs') // The VDMX records
});
var $627850fc9deed59a$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
numRecs: $gfJaN$restructure.uint16,
numRatios: $gfJaN$restructure.uint16,
ratioRanges: new $gfJaN$restructure.Array($627850fc9deed59a$var$Ratio, 'numRatios'),
offsets: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'numRatios'),
groups: new $gfJaN$restructure.Array($627850fc9deed59a$var$VdmxGroup, 'numRecs') // The actual VDMX groupings
});
var // Vertical Header Table
$65c33f5f068fc77f$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
ascent: $gfJaN$restructure.int16,
descent: $gfJaN$restructure.int16,
lineGap: $gfJaN$restructure.int16,
advanceHeightMax: $gfJaN$restructure.int16,
minTopSideBearing: $gfJaN$restructure.int16,
minBottomSideBearing: $gfJaN$restructure.int16,
yMaxExtent: $gfJaN$restructure.int16,
caretSlopeRise: $gfJaN$restructure.int16,
caretSlopeRun: $gfJaN$restructure.int16,
caretOffset: $gfJaN$restructure.int16,
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.int16, 4),
metricDataFormat: $gfJaN$restructure.int16,
numberOfMetrics: $gfJaN$restructure.uint16 // Number of advance heights in the Vertical Metrics table
});
let $597d739523b65bb3$var$VmtxEntry = new $gfJaN$restructure.Struct({
advance: $gfJaN$restructure.uint16,
bearing: $gfJaN$restructure.int16 // The top sidebearing of the glyph
});
var // Vertical Metrics Table
$597d739523b65bb3$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
metrics: new $gfJaN$restructure.LazyArray($597d739523b65bb3$var$VmtxEntry, (t)=>t.parent.vhea.numberOfMetrics),
bearings: new $gfJaN$restructure.LazyArray($gfJaN$restructure.int16, (t)=>t.parent.maxp.numGlyphs - t.parent.vhea.numberOfMetrics)
});
let $35aa0c87d9c3d3a0$var$shortFrac = new $gfJaN$restructure.Fixed(16, 'BE', 14);
let $35aa0c87d9c3d3a0$var$Correspondence = new $gfJaN$restructure.Struct({
fromCoord: $35aa0c87d9c3d3a0$var$shortFrac,
toCoord: $35aa0c87d9c3d3a0$var$shortFrac
});
let $35aa0c87d9c3d3a0$var$Segment = new $gfJaN$restructure.Struct({
pairCount: $gfJaN$restructure.uint16,
correspondence: new $gfJaN$restructure.Array($35aa0c87d9c3d3a0$var$Correspondence, 'pairCount')
});
var $35aa0c87d9c3d3a0$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.fixed32,
axisCount: $gfJaN$restructure.uint32,
segment: new $gfJaN$restructure.Array($35aa0c87d9c3d3a0$var$Segment, 'axisCount')
});
class $22801616bd931ca3$var$UnboundedArrayAccessor {
getItem(index) {
if (this._items[index] == null) {
let pos = this.stream.pos;
this.stream.pos = this.base + this.type.size(null, this.parent) * index;
this._items[index] = this.type.decode(this.stream, this.parent);
this.stream.pos = pos;
}
return this._items[index];
}
inspect() {
return `[UnboundedArray ${this.type.constructor.name}]`;
}
constructor(type, stream, parent){
this.type = type;
this.stream = stream;
this.parent = parent;
this.base = this.stream.pos;
this._items = [];
}
}
class $22801616bd931ca3$export$c5af1eebc882e39a extends $gfJaN$restructure.Array {
decode(stream, parent) {
return new $22801616bd931ca3$var$UnboundedArrayAccessor(this.type, stream, parent);
}
constructor(type){
super(type, 0);
}
}
let $22801616bd931ca3$export$8351f8c2ae2f103c = function(ValueType = $gfJaN$restructure.uint16) {
// Helper class that makes internal structures invisible to pointers
class Shadow {
decode(stream, ctx) {
ctx = ctx.parent.parent;
return this.type.decode(stream, ctx);
}
size(val, ctx) {
ctx = ctx.parent.parent;
return this.type.size(val, ctx);
}
encode(stream, val, ctx) {
ctx = ctx.parent.parent;
return this.type.encode(stream, val, ctx);
}
constructor(type){
this.type = type;
}
}
ValueType = new Shadow(ValueType);
let BinarySearchHeader = new $gfJaN$restructure.Struct({
unitSize: $gfJaN$restructure.uint16,
nUnits: $gfJaN$restructure.uint16,
searchRange: $gfJaN$restructure.uint16,
entrySelector: $gfJaN$restructure.uint16,
rangeShift: $gfJaN$restructure.uint16
});
let LookupSegmentSingle = new $gfJaN$restructure.Struct({
lastGlyph: $gfJaN$restructure.uint16,
firstGlyph: $gfJaN$restructure.uint16,
value: ValueType
});
let LookupSegmentArray = new $gfJaN$restructure.Struct({
lastGlyph: $gfJaN$restructure.uint16,
firstGlyph: $gfJaN$restructure.uint16,
values: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new $gfJaN$restructure.Array(ValueType, (t)=>t.lastGlyph - t.firstGlyph + 1), {
type: 'parent'
})
});
let LookupSingle = new $gfJaN$restructure.Struct({
glyph: $gfJaN$restructure.uint16,
value: ValueType
});
return new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint16, {
0: {
values: new $22801616bd931ca3$export$c5af1eebc882e39a(ValueType) // length == number of glyphs maybe?
},
2: {
binarySearchHeader: BinarySearchHeader,
segments: new $gfJaN$restructure.Array(LookupSegmentSingle, (t)=>t.binarySearchHeader.nUnits)
},
4: {
binarySearchHeader: BinarySearchHeader,
segments: new $gfJaN$restructure.Array(LookupSegmentArray, (t)=>t.binarySearchHeader.nUnits)
},
6: {
binarySearchHeader: BinarySearchHeader,
segments: new $gfJaN$restructure.Array(LookupSingle, (t)=>t.binarySearchHeader.nUnits)
},
8: {
firstGlyph: $gfJaN$restructure.uint16,
count: $gfJaN$restructure.uint16,
values: new $gfJaN$restructure.Array(ValueType, 'count')
}
});
};
function $22801616bd931ca3$export$79f7d93d790934ba(entryData = {}, lookupType = $gfJaN$restructure.uint16) {
let entry = Object.assign({
newState: $gfJaN$restructure.uint16,
flags: $gfJaN$restructure.uint16
}, entryData);
let Entry = new $gfJaN$restructure.Struct(entry);
let StateArray = new $22801616bd931ca3$export$c5af1eebc882e39a(new $gfJaN$restructure.Array($gfJaN$restructure.uint16, (t)=>t.nClasses));
let StateHeader = new $gfJaN$restructure.Struct({
nClasses: $gfJaN$restructure.uint32,
classTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $22801616bd931ca3$export$8351f8c2ae2f103c(lookupType)),
stateArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, StateArray),
entryTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $22801616bd931ca3$export$c5af1eebc882e39a(Entry))
});
return StateHeader;
}
function $22801616bd931ca3$export$105027425199cc51(entryData = {}, lookupType = $gfJaN$restructure.uint16) {
let ClassLookupTable = new $gfJaN$restructure.Struct({
version () {
return 8;
},
firstGlyph: $gfJaN$restructure.uint16,
values: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, $gfJaN$restructure.uint16)
});
let entry = Object.assign({
newStateOffset: $gfJaN$restructure.uint16,
// convert offset to stateArray index
newState: (t)=>(t.newStateOffset - (t.parent.stateArray.base - t.parent._startOffset)) / t.parent.nClasses,
flags: $gfJaN$restructure.uint16
}, entryData);
let Entry = new $gfJaN$restructure.Struct(entry);
let StateArray = new $22801616bd931ca3$export$c5af1eebc882e39a(new $gfJaN$restructure.Array($gfJaN$restructure.uint8, (t)=>t.nClasses));
let StateHeader1 = new $gfJaN$restructure.Struct({
nClasses: $gfJaN$restructure.uint16,
classTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, ClassLookupTable),
stateArray: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, StateArray),
entryTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new $22801616bd931ca3$export$c5af1eebc882e39a(Entry))
});
return StateHeader1;
}
let $3a5ca96d3e3aaf20$var$BslnSubtable = new $gfJaN$restructure.VersionedStruct('format', {
0: {
deltas: new $gfJaN$restructure.Array($gfJaN$restructure.int16, 32)
},
1: {
deltas: new $gfJaN$restructure.Array($gfJaN$restructure.int16, 32),
mappingData: new (0, $22801616bd931ca3$export$8351f8c2ae2f103c)($gfJaN$restructure.uint16)
},
2: {
standardGlyph: $gfJaN$restructure.uint16,
controlPoints: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 32)
},
3: {
standardGlyph: $gfJaN$restructure.uint16,
controlPoints: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 32),
mappingData: new (0, $22801616bd931ca3$export$8351f8c2ae2f103c)($gfJaN$restructure.uint16)
}
});
var $3a5ca96d3e3aaf20$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.fixed32,
format: $gfJaN$restructure.uint16,
defaultBaseline: $gfJaN$restructure.uint16,
subtable: $3a5ca96d3e3aaf20$var$BslnSubtable
});
let $8d4241d96b2b0589$var$Setting = new $gfJaN$restructure.Struct({
setting: $gfJaN$restructure.uint16,
nameIndex: $gfJaN$restructure.int16,
name: (t)=>t.parent.parent.parent.name.records.fontFeatures[t.nameIndex]
});
let $8d4241d96b2b0589$var$FeatureName = new $gfJaN$restructure.Struct({
feature: $gfJaN$restructure.uint16,
nSettings: $gfJaN$restructure.uint16,
settingTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array($8d4241d96b2b0589$var$Setting, 'nSettings'), {
type: 'parent'
}),
featureFlags: new $gfJaN$restructure.Bitfield($gfJaN$restructure.uint8, [
null,
null,
null,
null,
null,
null,
'hasDefault',
'exclusive'
]),
defaultSetting: $gfJaN$restructure.uint8,
nameIndex: $gfJaN$restructure.int16,
name: (t)=>t.parent.parent.name.records.fontFeatures[t.nameIndex]
});
var $8d4241d96b2b0589$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.fixed32,
featureNameCount: $gfJaN$restructure.uint16,
reserved1: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
reserved2: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint32),
featureNames: new $gfJaN$restructure.Array($8d4241d96b2b0589$var$FeatureName, 'featureNameCount')
});
let $a79cd5132b1cf476$var$Axis = new $gfJaN$restructure.Struct({
axisTag: new $gfJaN$restructure.String(4),
minValue: $gfJaN$restructure.fixed32,
defaultValue: $gfJaN$restructure.fixed32,
maxValue: $gfJaN$restructure.fixed32,
flags: $gfJaN$restructure.uint16,
nameID: $gfJaN$restructure.uint16,
name: (t)=>t.parent.parent.name.records.fontFeatures[t.nameID]
});
let $a79cd5132b1cf476$var$Instance = new $gfJaN$restructure.Struct({
nameID: $gfJaN$restructure.uint16,
name: (t)=>t.parent.parent.name.records.fontFeatures[t.nameID],
flags: $gfJaN$restructure.uint16,
coord: new $gfJaN$restructure.Array($gfJaN$restructure.fixed32, (t)=>t.parent.axisCount),
postscriptNameID: new $gfJaN$restructure.Optional($gfJaN$restructure.uint16, (t)=>t.parent.instanceSize - t._currentOffset > 0)
});
var $a79cd5132b1cf476$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.fixed32,
offsetToData: $gfJaN$restructure.uint16,
countSizePairs: $gfJaN$restructure.uint16,
axisCount: $gfJaN$restructure.uint16,
axisSize: $gfJaN$restructure.uint16,
instanceCount: $gfJaN$restructure.uint16,
instanceSize: $gfJaN$restructure.uint16,
axis: new $gfJaN$restructure.Array($a79cd5132b1cf476$var$Axis, 'axisCount'),
instance: new $gfJaN$restructure.Array($a79cd5132b1cf476$var$Instance, 'instanceCount')
});
let $3f36f1a5e6989457$var$shortFrac = new $gfJaN$restructure.Fixed(16, 'BE', 14);
class $3f36f1a5e6989457$var$Offset {
static decode(stream, parent) {
// In short format, offsets are multiplied by 2.
// This doesn't seem to be documented by Apple, but it
// is implemented this way in Freetype.
return parent.flags ? stream.readUInt32BE() : stream.readUInt16BE() * 2;
}
}
let $3f36f1a5e6989457$var$gvar = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
axisCount: $gfJaN$restructure.uint16,
globalCoordCount: $gfJaN$restructure.uint16,
globalCoords: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new $gfJaN$restructure.Array(new $gfJaN$restructure.Array($3f36f1a5e6989457$var$shortFrac, 'axisCount'), 'globalCoordCount')),
glyphCount: $gfJaN$restructure.uint16,
flags: $gfJaN$restructure.uint16,
offsetToData: $gfJaN$restructure.uint32,
offsets: new $gfJaN$restructure.Array(new $gfJaN$restructure.Pointer($3f36f1a5e6989457$var$Offset, 'void', {
relativeTo: (ctx)=>ctx.offsetToData,
allowNull: false
}), (t)=>t.glyphCount + 1)
});
var $3f36f1a5e6989457$export$2e2bcd8739ae039 = $3f36f1a5e6989457$var$gvar;
let $0bd8fe7a6d1d9fb4$var$ClassTable = new $gfJaN$restructure.Struct({
length: $gfJaN$restructure.uint16,
coverage: $gfJaN$restructure.uint16,
subFeatureFlags: $gfJaN$restructure.uint32,
stateTable: new (0, $22801616bd931ca3$export$105027425199cc51)
});
let $0bd8fe7a6d1d9fb4$var$WidthDeltaRecord = new $gfJaN$restructure.Struct({
justClass: $gfJaN$restructure.uint32,
beforeGrowLimit: $gfJaN$restructure.fixed32,
beforeShrinkLimit: $gfJaN$restructure.fixed32,
afterGrowLimit: $gfJaN$restructure.fixed32,
afterShrinkLimit: $gfJaN$restructure.fixed32,
growFlags: $gfJaN$restructure.uint16,
shrinkFlags: $gfJaN$restructure.uint16
});
let $0bd8fe7a6d1d9fb4$var$WidthDeltaCluster = new $gfJaN$restructure.Array($0bd8fe7a6d1d9fb4$var$WidthDeltaRecord, $gfJaN$restructure.uint32);
let $0bd8fe7a6d1d9fb4$var$ActionData = new $gfJaN$restructure.VersionedStruct('actionType', {
0: {
lowerLimit: $gfJaN$restructure.fixed32,
upperLimit: $gfJaN$restructure.fixed32,
order: $gfJaN$restructure.uint16,
glyphs: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, $gfJaN$restructure.uint16)
},
1: {
addGlyph: $gfJaN$restructure.uint16
},
2: {
substThreshold: $gfJaN$restructure.fixed32,
addGlyph: $gfJaN$restructure.uint16,
substGlyph: $gfJaN$restructure.uint16
},
3: {},
4: {
variationAxis: $gfJaN$restructure.uint32,
minimumLimit: $gfJaN$restructure.fixed32,
noStretchValue: $gfJaN$restructure.fixed32,
maximumLimit: $gfJaN$restructure.fixed32
},
5: {
flags: $gfJaN$restructure.uint16,
glyph: $gfJaN$restructure.uint16
}
});
let $0bd8fe7a6d1d9fb4$var$Action = new $gfJaN$restructure.Struct({
actionClass: $gfJaN$restructure.uint16,
actionType: $gfJaN$restructure.uint16,
actionLength: $gfJaN$restructure.uint32,
actionData: $0bd8fe7a6d1d9fb4$var$ActionData,
padding: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8, (t)=>t.actionLength - t._currentOffset)
});
let $0bd8fe7a6d1d9fb4$var$PostcompensationAction = new $gfJaN$restructure.Array($0bd8fe7a6d1d9fb4$var$Action, $gfJaN$restructure.uint32);
let $0bd8fe7a6d1d9fb4$var$PostCompensationTable = new $gfJaN$restructure.Struct({
lookupTable: new (0, $22801616bd931ca3$export$8351f8c2ae2f103c)(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $0bd8fe7a6d1d9fb4$var$PostcompensationAction))
});
let $0bd8fe7a6d1d9fb4$var$JustificationTable = new $gfJaN$restructure.Struct({
classTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $0bd8fe7a6d1d9fb4$var$ClassTable, {
type: 'parent'
}),
wdcOffset: $gfJaN$restructure.uint16,
postCompensationTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $0bd8fe7a6d1d9fb4$var$PostCompensationTable, {
type: 'parent'
}),
widthDeltaClusters: new (0, $22801616bd931ca3$export$8351f8c2ae2f103c)(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $0bd8fe7a6d1d9fb4$var$WidthDeltaCluster, {
type: 'parent',
relativeTo: (ctx)=>ctx.wdcOffset
}))
});
var $0bd8fe7a6d1d9fb4$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint32,
format: $gfJaN$restructure.uint16,
horizontal: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $0bd8fe7a6d1d9fb4$var$JustificationTable),
vertical: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $0bd8fe7a6d1d9fb4$var$JustificationTable)
});
let $ef40c6dc80fd50a2$var$LigatureData = {
action: $gfJaN$restructure.uint16
};
let $ef40c6dc80fd50a2$var$ContextualData = {
markIndex: $gfJaN$restructure.uint16,
currentIndex: $gfJaN$restructure.uint16
};
let $ef40c6dc80fd50a2$var$InsertionData = {
currentInsertIndex: $gfJaN$restructure.uint16,
markedInsertIndex: $gfJaN$restructure.uint16
};
let $ef40c6dc80fd50a2$var$SubstitutionTable = new $gfJaN$restructure.Struct({
items: new (0, $22801616bd931ca3$export$c5af1eebc882e39a)(new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new (0, $22801616bd931ca3$export$8351f8c2ae2f103c)))
});
let $ef40c6dc80fd50a2$var$SubtableData = new $gfJaN$restructure.VersionedStruct('type', {
0: {
stateTable: new (0, $22801616bd931ca3$export$79f7d93d790934ba)
},
1: {
stateTable: new (0, $22801616bd931ca3$export$79f7d93d790934ba)($ef40c6dc80fd50a2$var$ContextualData),
substitutionTable: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $ef40c6dc80fd50a2$var$SubstitutionTable)
},
2: {
stateTable: new (0, $22801616bd931ca3$export$79f7d93d790934ba)($ef40c6dc80fd50a2$var$LigatureData),
ligatureActions: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new (0, $22801616bd931ca3$export$c5af1eebc882e39a)($gfJaN$restructure.uint32)),
components: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new (0, $22801616bd931ca3$export$c5af1eebc882e39a)($gfJaN$restructure.uint16)),
ligatureList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new (0, $22801616bd931ca3$export$c5af1eebc882e39a)($gfJaN$restructure.uint16))
},
4: {
lookupTable: new (0, $22801616bd931ca3$export$8351f8c2ae2f103c)
},
5: {
stateTable: new (0, $22801616bd931ca3$export$79f7d93d790934ba)($ef40c6dc80fd50a2$var$InsertionData),
insertionActions: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, new (0, $22801616bd931ca3$export$c5af1eebc882e39a)($gfJaN$restructure.uint16))
}
});
let $ef40c6dc80fd50a2$var$Subtable = new $gfJaN$restructure.Struct({
length: $gfJaN$restructure.uint32,
coverage: $gfJaN$restructure.uint24,
type: $gfJaN$restructure.uint8,
subFeatureFlags: $gfJaN$restructure.uint32,
table: $ef40c6dc80fd50a2$var$SubtableData,
padding: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8, (t)=>t.length - t._currentOffset)
});
let $ef40c6dc80fd50a2$var$FeatureEntry = new $gfJaN$restructure.Struct({
featureType: $gfJaN$restructure.uint16,
featureSetting: $gfJaN$restructure.uint16,
enableFlags: $gfJaN$restructure.uint32,
disableFlags: $gfJaN$restructure.uint32
});
let $ef40c6dc80fd50a2$var$MorxChain = new $gfJaN$restructure.Struct({
defaultFlags: $gfJaN$restructure.uint32,
chainLength: $gfJaN$restructure.uint32,
nFeatureEntries: $gfJaN$restructure.uint32,
nSubtables: $gfJaN$restructure.uint32,
features: new $gfJaN$restructure.Array($ef40c6dc80fd50a2$var$FeatureEntry, 'nFeatureEntries'),
subtables: new $gfJaN$restructure.Array($ef40c6dc80fd50a2$var$Subtable, 'nSubtables')
});
var $ef40c6dc80fd50a2$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint16,
unused: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
nChains: $gfJaN$restructure.uint32,
chains: new $gfJaN$restructure.Array($ef40c6dc80fd50a2$var$MorxChain, 'nChains')
});
let $ab24dea08b58a7cc$var$OpticalBounds = new $gfJaN$restructure.Struct({
left: $gfJaN$restructure.int16,
top: $gfJaN$restructure.int16,
right: $gfJaN$restructure.int16,
bottom: $gfJaN$restructure.int16
});
var $ab24dea08b58a7cc$export$2e2bcd8739ae039 = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.fixed32,
format: $gfJaN$restructure.uint16,
lookupTable: new (0, $22801616bd931ca3$export$8351f8c2ae2f103c)($ab24dea08b58a7cc$var$OpticalBounds)
});
let $5825c04ce8f7102d$var$tables = {};
var $5825c04ce8f7102d$export$2e2bcd8739ae039 = $5825c04ce8f7102d$var$tables;
$5825c04ce8f7102d$var$tables.cmap = (0, $e4ae0436c91af89f$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.head = (0, $55a60976afb7c261$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.hhea = (0, $dde72b7b5b650596$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.hmtx = (0, $a7c40184072c9a5b$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.maxp = (0, $521197722369f691$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.name = (0, $51a9f4feb3a3b2b1$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables['OS/2'] = (0, $114ea85db469b435$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.post = (0, $f93b30299e1ea0f5$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.fpgm = (0, $873d79fea57d3161$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.loca = (0, $83c4155666d50c37$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.prep = (0, $b12598db7cdf7042$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables['cvt '] = (0, $8fb09b0f473d61a0$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.glyf = (0, $7707bdf21a3d89cc$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables['CFF '] = (0, $f717432b360040c7$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables['CFF2'] = (0, $f717432b360040c7$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.VORG = (0, $8cb7ae73ed7aa7d8$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.EBLC = (0, $035bb95c0cdb1f6d$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.CBLC = $5825c04ce8f7102d$var$tables.EBLC;
$5825c04ce8f7102d$var$tables.sbix = (0, $73d13900b55a3c0c$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.COLR = (0, $97f6b8be3a347a8f$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.CPAL = (0, $16ca60ecbdee30ea$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.BASE = (0, $7327e41706f9d5c7$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.GDEF = (0, $7e48bbe9e5345664$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.GPOS = (0, $b687332511a4da75$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.GSUB = (0, $99ccad60b96f92fb$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.JSTF = (0, $573d5042c76c4940$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.HVAR = (0, $a5875b80d6087f61$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.DSIG = (0, $4423bc1ac09bbbd1$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.gasp = (0, $7b50e3f8d83263de$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.hdmx = (0, $7bf92ec372cd2307$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.kern = (0, $a3f544bcf76542d1$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.LTSH = (0, $86687befb45925d0$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.PCLT = (0, $91429006e51e0fe8$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.VDMX = (0, $627850fc9deed59a$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.vhea = (0, $65c33f5f068fc77f$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.vmtx = (0, $597d739523b65bb3$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.avar = (0, $35aa0c87d9c3d3a0$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.bsln = (0, $3a5ca96d3e3aaf20$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.feat = (0, $8d4241d96b2b0589$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.fvar = (0, $a79cd5132b1cf476$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.gvar = (0, $3f36f1a5e6989457$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.just = (0, $0bd8fe7a6d1d9fb4$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.morx = (0, $ef40c6dc80fd50a2$export$2e2bcd8739ae039);
$5825c04ce8f7102d$var$tables.opbd = (0, $ab24dea08b58a7cc$export$2e2bcd8739ae039);
let $df50e1efe10a1247$var$TableEntry = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
checkSum: $gfJaN$restructure.uint32,
offset: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, 'void', {
type: 'global'
}),
length: $gfJaN$restructure.uint32
});
let $df50e1efe10a1247$var$Directory = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
numTables: $gfJaN$restructure.uint16,
searchRange: $gfJaN$restructure.uint16,
entrySelector: $gfJaN$restructure.uint16,
rangeShift: $gfJaN$restructure.uint16,
tables: new $gfJaN$restructure.Array($df50e1efe10a1247$var$TableEntry, 'numTables')
});
$df50e1efe10a1247$var$Directory.process = function() {
let tables = {};
for (let table of this.tables)tables[table.tag] = table;
this.tables = tables;
};
$df50e1efe10a1247$var$Directory.preEncode = function() {
if (!Array.isArray(this.tables)) {
let tables = [];
for(let tag in this.tables){
let table = this.tables[tag];
if (table) tables.push({
tag: tag,
checkSum: 0,
offset: new $gfJaN$restructure.VoidPointer((0, $5825c04ce8f7102d$export$2e2bcd8739ae039)[tag], table),
length: (0, $5825c04ce8f7102d$export$2e2bcd8739ae039)[tag].size(table)
});
}
this.tables = tables;
}
this.tag = 'true';
this.numTables = this.tables.length;
let maxExponentFor2 = Math.floor(Math.log(this.numTables) / Math.LN2);
let maxPowerOf2 = Math.pow(2, maxExponentFor2);
this.searchRange = maxPowerOf2 * 16;
this.entrySelector = Math.log(maxPowerOf2) / Math.LN2;
this.rangeShift = this.numTables * 16 - this.searchRange;
};
var $df50e1efe10a1247$export$2e2bcd8739ae039 = $df50e1efe10a1247$var$Directory;
function $66a5b9fb5318558a$export$2e0ae67339d5f1ac(arr, cmp) {
let min = 0;
let max = arr.length - 1;
while(min <= max){
let mid = min + max >> 1;
let res = cmp(arr[mid]);
if (res < 0) max = mid - 1;
else if (res > 0) min = mid + 1;
else return mid;
}
return -1;
}
function $66a5b9fb5318558a$export$d02631cccf789723(index, end) {
let range = [];
while(index < end)range.push(index++);
return range;
}
const $66a5b9fb5318558a$export$3d28c1996ced1f14 = new TextDecoder('ascii');
// Based on https://github.com/niklasvh/base64-arraybuffer. MIT license.
const $66a5b9fb5318558a$var$CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
const $66a5b9fb5318558a$var$LOOKUP = new Uint8Array(256);
for(let i = 0; i < $66a5b9fb5318558a$var$CHARS.length; i++)$66a5b9fb5318558a$var$LOOKUP[$66a5b9fb5318558a$var$CHARS.charCodeAt(i)] = i;
function $66a5b9fb5318558a$export$94fdf11bafc8de6b(base64) {
let bufferLength = base64.length * 0.75;
if (base64[base64.length - 1] === '=') {
bufferLength--;
if (base64[base64.length - 2] === '=') bufferLength--;
}
let bytes = new Uint8Array(bufferLength);
let p = 0;
for(let i = 0, len = base64.length; i < len; i += 4){
let encoded1 = $66a5b9fb5318558a$var$LOOKUP[base64.charCodeAt(i)];
let encoded2 = $66a5b9fb5318558a$var$LOOKUP[base64.charCodeAt(i + 1)];
let encoded3 = $66a5b9fb5318558a$var$LOOKUP[base64.charCodeAt(i + 2)];
let encoded4 = $66a5b9fb5318558a$var$LOOKUP[base64.charCodeAt(i + 3)];
bytes[p++] = encoded1 << 2 | encoded2 >> 4;
bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
}
return bytes;
}
class $0d6e160064c86e50$export$2e2bcd8739ae039 {
findSubtable(cmapTable, pairs) {
for (let [platformID, encodingID] of pairs)for (let cmap of cmapTable.tables){
if (cmap.platformID === platformID && cmap.encodingID === encodingID) return cmap.table;
}
return null;
}
lookup(codepoint, variationSelector) {
// If there is no Unicode cmap in this font, we need to re-encode
// the codepoint in the encoding that the cmap supports.
if (this.encoding) codepoint = this.encoding.get(codepoint) || codepoint;
else if (variationSelector) {
let gid = this.getVariationSelector(codepoint, variationSelector);
if (gid) return gid;
}
let cmap = this.cmap;
switch(cmap.version){
case 0:
return cmap.codeMap.get(codepoint) || 0;
case 4:
{
let min = 0;
let max = cmap.segCount - 1;
while(min <= max){
let mid = min + max >> 1;
if (codepoint < cmap.startCode.get(mid)) max = mid - 1;
else if (codepoint > cmap.endCode.get(mid)) min = mid + 1;
else {
let rangeOffset = cmap.idRangeOffset.get(mid);
let gid;
if (rangeOffset === 0) gid = codepoint + cmap.idDelta.get(mid);
else {
let index = rangeOffset / 2 + (codepoint - cmap.startCode.get(mid)) - (cmap.segCount - mid);
gid = cmap.glyphIndexArray.get(index) || 0;
if (gid !== 0) gid += cmap.idDelta.get(mid);
}
return gid & 0xffff;
}
}
return 0;
}
case 8:
throw new Error('TODO: cmap format 8');
case 6:
case 10:
return cmap.glyphIndices.get(codepoint - cmap.firstCode) || 0;
case 12:
case 13:
{
let min = 0;
let max = cmap.nGroups - 1;
while(min <= max){
let mid = min + max >> 1;
let group = cmap.groups.get(mid);
if (codepoint < group.startCharCode) max = mid - 1;
else if (codepoint > group.endCharCode) min = mid + 1;
else {
if (cmap.version === 12) return group.glyphID + (codepoint - group.startCharCode);
else return group.glyphID;
}
}
return 0;
}
case 14:
throw new Error('TODO: cmap format 14');
default:
throw new Error(`Unknown cmap format ${cmap.version}`);
}
}
getVariationSelector(codepoint, variationSelector) {
if (!this.uvs) return 0;
let selectors = this.uvs.varSelectors.toArray();
let i = (0, $66a5b9fb5318558a$export$2e0ae67339d5f1ac)(selectors, (x)=>variationSelector - x.varSelector);
let sel = selectors[i];
if (i !== -1 && sel.defaultUVS) i = (0, $66a5b9fb5318558a$export$2e0ae67339d5f1ac)(sel.defaultUVS, (x)=>codepoint < x.startUnicodeValue ? -1 : codepoint > x.startUnicodeValue + x.additionalCount ? 1 : 0);
if (i !== -1 && sel.nonDefaultUVS) {
i = (0, $66a5b9fb5318558a$export$2e0ae67339d5f1ac)(sel.nonDefaultUVS, (x)=>codepoint - x.unicodeValue);
if (i !== -1) return sel.nonDefaultUVS[i].glyphID;
}
return 0;
}
getCharacterSet() {
let cmap = this.cmap;
switch(cmap.version){
case 0:
return (0, $66a5b9fb5318558a$export$d02631cccf789723)(0, cmap.codeMap.length);
case 4:
{
let res = [];
let endCodes = cmap.endCode.toArray();
for(let i = 0; i < endCodes.length; i++){
let tail = endCodes[i] + 1;
let start = cmap.startCode.get(i);
res.push(...(0, $66a5b9fb5318558a$export$d02631cccf789723)(start, tail));
}
return res;
}
case 8:
throw new Error('TODO: cmap format 8');
case 6:
case 10:
return (0, $66a5b9fb5318558a$export$d02631cccf789723)(cmap.firstCode, cmap.firstCode + cmap.glyphIndices.length);
case 12:
case 13:
{
let res = [];
for (let group of cmap.groups.toArray())res.push(...(0, $66a5b9fb5318558a$export$d02631cccf789723)(group.startCharCode, group.endCharCode + 1));
return res;
}
case 14:
throw new Error('TODO: cmap format 14');
default:
throw new Error(`Unknown cmap format ${cmap.version}`);
}
}
codePointsForGlyph(gid) {
let cmap = this.cmap;
switch(cmap.version){
case 0:
{
let res = [];
for(let i = 0; i < 256; i++)if (cmap.codeMap.get(i) === gid) res.push(i);
return res;
}
case 4:
{
let res = [];
for(let i = 0; i < cmap.segCount; i++){
let end = cmap.endCode.get(i);
let start = cmap.startCode.get(i);
let rangeOffset = cmap.idRangeOffset.get(i);
let delta = cmap.idDelta.get(i);
for(var c = start; c <= end; c++){
let g = 0;
if (rangeOffset === 0) g = c + delta;
else {
let index = rangeOffset / 2 + (c - start) - (cmap.segCount - i);
g = cmap.glyphIndexArray.get(index) || 0;
if (g !== 0) g += delta;
}
if (g === gid) res.push(c);
}
}
return res;
}
case 12:
{
let res = [];
for (let group of cmap.groups.toArray())if (gid >= group.glyphID && gid <= group.glyphID + (group.endCharCode - group.startCharCode)) res.push(group.startCharCode + (gid - group.glyphID));
return res;
}
case 13:
{
let res = [];
for (let group of cmap.groups.toArray())if (gid === group.glyphID) res.push(...(0, $66a5b9fb5318558a$export$d02631cccf789723)(group.startCharCode, group.endCharCode + 1));
return res;
}
default:
throw new Error(`Unknown cmap format ${cmap.version}`);
}
}
constructor(cmapTable){
// Attempt to find a Unicode cmap first
this.encoding = null;
this.cmap = this.findSubtable(cmapTable, [
// 32-bit subtables
[
3,
10
],
[
0,
6
],
[
0,
4
],
// 16-bit subtables
[
3,
1
],
[
0,
3
],
[
0,
2
],
[
0,
1
],
[
0,
0
]
]);
// If not unicode cmap was found, take the first table with a supported encoding.
if (!this.cmap) for (let cmap of cmapTable.tables){
let encoding = (0, $e2613b812f052cbe$export$badc544e0651b6b1)(cmap.platformID, cmap.encodingID, cmap.table.language - 1);
let mapping = (0, $e2613b812f052cbe$export$1dceb3c14ed68bee)(encoding);
if (mapping) {
this.cmap = cmap.table;
this.encoding = mapping;
}
}
if (!this.cmap) throw new Error("Could not find a supported cmap table");
this.uvs = this.findSubtable(cmapTable, [
[
0,
5
]
]);
if (this.uvs && this.uvs.version !== 14) this.uvs = null;
}
}
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0d6e160064c86e50$export$2e2bcd8739ae039.prototype, "getCharacterSet", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0d6e160064c86e50$export$2e2bcd8739ae039.prototype, "codePointsForGlyph", null);
class $4646d52c2a559cdb$export$2e2bcd8739ae039 {
process(glyphs, positions) {
for(let glyphIndex = 0; glyphIndex < glyphs.length - 1; glyphIndex++){
let left = glyphs[glyphIndex].id;
let right = glyphs[glyphIndex + 1].id;
positions[glyphIndex].xAdvance += this.getKerning(left, right);
}
}
getKerning(left, right) {
let res = 0;
for (let table of this.kern.tables){
if (table.coverage.crossStream) continue;
switch(table.version){
case 0:
if (!table.coverage.horizontal) continue;
break;
case 1:
if (table.coverage.vertical || table.coverage.variation) continue;
break;
default:
throw new Error(`Unsupported kerning table version ${table.version}`);
}
let val = 0;
let s = table.subtable;
switch(table.format){
case 0:
let pairIdx = (0, $66a5b9fb5318558a$export$2e0ae67339d5f1ac)(s.pairs, function(pair) {
return left - pair.left || right - pair.right;
});
if (pairIdx >= 0) val = s.pairs[pairIdx].value;
break;
case 2:
let leftOffset = 0, rightOffset = 0;
if (left >= s.leftTable.firstGlyph && left < s.leftTable.firstGlyph + s.leftTable.nGlyphs) leftOffset = s.leftTable.offsets[left - s.leftTable.firstGlyph];
else leftOffset = s.array.off;
if (right >= s.rightTable.firstGlyph && right < s.rightTable.firstGlyph + s.rightTable.nGlyphs) rightOffset = s.rightTable.offsets[right - s.rightTable.firstGlyph];
let index = (leftOffset + rightOffset - s.array.off) / 2;
val = s.array.values.get(index);
break;
case 3:
if (left >= s.glyphCount || right >= s.glyphCount) return 0;
val = s.kernValue[s.kernIndex[s.leftClass[left] * s.rightClassCount + s.rightClass[right]]];
break;
default:
throw new Error(`Unsupported kerning sub-table format ${table.format}`);
}
// Microsoft supports the override flag, which resets the result
// Otherwise, the sum of the results from all subtables is returned
if (table.coverage.override) res = val;
else res += val;
}
return res;
}
constructor(font){
this.kern = font.kern;
}
}
class $a57a26817cd35108$export$2e2bcd8739ae039 {
positionGlyphs(glyphs, positions) {
// find each base + mark cluster, and position the marks relative to the base
let clusterStart = 0;
let clusterEnd = 0;
for(let index = 0; index < glyphs.length; index++){
let glyph = glyphs[index];
if (glyph.isMark) clusterEnd = index;
else {
if (clusterStart !== clusterEnd) this.positionCluster(glyphs, positions, clusterStart, clusterEnd);
clusterStart = clusterEnd = index;
}
}
if (clusterStart !== clusterEnd) this.positionCluster(glyphs, positions, clusterStart, clusterEnd);
return positions;
}
positionCluster(glyphs, positions, clusterStart, clusterEnd) {
let base = glyphs[clusterStart];
let baseBox = base.cbox.copy();
// adjust bounding box for ligature glyphs
if (base.codePoints.length > 1) // LTR. TODO: RTL support.
baseBox.minX += (base.codePoints.length - 1) * baseBox.width / base.codePoints.length;
let xOffset = -positions[clusterStart].xAdvance;
let yOffset = 0;
let yGap = this.font.unitsPerEm / 16;
// position each of the mark glyphs relative to the base glyph
for(let index = clusterStart + 1; index <= clusterEnd; index++){
let mark = glyphs[index];
let markBox = mark.cbox;
let position = positions[index];
let combiningClass = this.getCombiningClass(mark.codePoints[0]);
if (combiningClass !== 'Not_Reordered') {
position.xOffset = position.yOffset = 0;
// x positioning
switch(combiningClass){
case 'Double_Above':
case 'Double_Below':
// LTR. TODO: RTL support.
position.xOffset += baseBox.minX - markBox.width / 2 - markBox.minX;
break;
case 'Attached_Below_Left':
case 'Below_Left':
case 'Above_Left':
// left align
position.xOffset += baseBox.minX - markBox.minX;
break;
case 'Attached_Above_Right':
case 'Below_Right':
case 'Above_Right':
// right align
position.xOffset += baseBox.maxX - markBox.width - markBox.minX;
break;
default:
// center align
position.xOffset += baseBox.minX + (baseBox.width - markBox.width) / 2 - markBox.minX;
}
// y positioning
switch(combiningClass){
case 'Double_Below':
case 'Below_Left':
case 'Below':
case 'Below_Right':
case 'Attached_Below_Left':
case 'Attached_Below':
// add a small gap between the glyphs if they are not attached
if (combiningClass === 'Attached_Below_Left' || combiningClass === 'Attached_Below') baseBox.minY += yGap;
position.yOffset = -baseBox.minY - markBox.maxY;
baseBox.minY += markBox.height;
break;
case 'Double_Above':
case 'Above_Left':
case 'Above':
case 'Above_Right':
case 'Attached_Above':
case 'Attached_Above_Right':
// add a small gap between the glyphs if they are not attached
if (combiningClass === 'Attached_Above' || combiningClass === 'Attached_Above_Right') baseBox.maxY += yGap;
position.yOffset = baseBox.maxY - markBox.minY;
baseBox.maxY += markBox.height;
break;
}
position.xAdvance = position.yAdvance = 0;
position.xOffset += xOffset;
position.yOffset += yOffset;
} else {
xOffset -= position.xAdvance;
yOffset -= position.yAdvance;
}
}
return;
}
getCombiningClass(codePoint) {
let combiningClass = (0, $gfJaN$unicodeproperties.getCombiningClass)(codePoint);
// Thai / Lao need some per-character work
if ((codePoint & -256) === 0x0e00) {
if (combiningClass === 'Not_Reordered') switch(codePoint){
case 0x0e31:
case 0x0e34:
case 0x0e35:
case 0x0e36:
case 0x0e37:
case 0x0e47:
case 0x0e4c:
case 0x0e3d:
case 0x0e4e:
return 'Above_Right';
case 0x0eb1:
case 0x0eb4:
case 0x0eb5:
case 0x0eb6:
case 0x0eb7:
case 0x0ebb:
case 0x0ecc:
case 0x0ecd:
return 'Above';
case 0x0ebc:
return 'Below';
}
else if (codePoint === 0x0e3a) return 'Below_Right';
}
switch(combiningClass){
// Hebrew
case 'CCC10':
case 'CCC11':
case 'CCC12':
case 'CCC13':
case 'CCC14':
case 'CCC15':
case 'CCC16':
case 'CCC17':
case 'CCC18':
case 'CCC20':
case 'CCC22':
return 'Below';
case 'CCC23':
return 'Attached_Above';
case 'CCC24':
return 'Above_Right';
case 'CCC25':
case 'CCC19':
return 'Above_Left';
case 'CCC26':
return 'Above';
case 'CCC21':
break;
// Arabic and Syriac
case 'CCC27':
case 'CCC28':
case 'CCC30':
case 'CCC31':
case 'CCC33':
case 'CCC34':
case 'CCC35':
case 'CCC36':
return 'Above';
case 'CCC29':
case 'CCC32':
return 'Below';
// Thai
case 'CCC103':
return 'Below_Right';
case 'CCC107':
return 'Above_Right';
// Lao
case 'CCC118':
return 'Below';
case 'CCC122':
return 'Above';
// Tibetan
case 'CCC129':
case 'CCC132':
return 'Below';
case 'CCC130':
return 'Above';
}
return combiningClass;
}
constructor(font){
this.font = font;
}
}
/**
* Represents a glyph bounding box
*/ class $0e2da1c4ce69e8ad$export$2e2bcd8739ae039 {
/**
* The width of the bounding box
* @type {number}
*/ get width() {
return this.maxX - this.minX;
}
/**
* The height of the bounding box
* @type {number}
*/ get height() {
return this.maxY - this.minY;
}
addPoint(x, y) {
if (Math.abs(x) !== Infinity) {
if (x < this.minX) this.minX = x;
if (x > this.maxX) this.maxX = x;
}
if (Math.abs(y) !== Infinity) {
if (y < this.minY) this.minY = y;
if (y > this.maxY) this.maxY = y;
}
}
copy() {
return new $0e2da1c4ce69e8ad$export$2e2bcd8739ae039(this.minX, this.minY, this.maxX, this.maxY);
}
constructor(minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity){
/**
* The minimum X position in the bounding box
* @type {number}
*/ this.minX = minX;
/**
* The minimum Y position in the bounding box
* @type {number}
*/ this.minY = minY;
/**
* The maxmimum X position in the bounding box
* @type {number}
*/ this.maxX = maxX;
/**
* The maxmimum Y position in the bounding box
* @type {number}
*/ this.maxY = maxY;
}
}
// This maps the Unicode Script property to an OpenType script tag
// Data from http://www.microsoft.com/typography/otspec/scripttags.htm
// and http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt.
const $e38a1a895f6aeb54$var$UNICODE_SCRIPTS = {
Caucasian_Albanian: 'aghb',
Arabic: 'arab',
Imperial_Aramaic: 'armi',
Armenian: 'armn',
Avestan: 'avst',
Balinese: 'bali',
Bamum: 'bamu',
Bassa_Vah: 'bass',
Batak: 'batk',
Bengali: [
'bng2',
'beng'
],
Bopomofo: 'bopo',
Brahmi: 'brah',
Braille: 'brai',
Buginese: 'bugi',
Buhid: 'buhd',
Chakma: 'cakm',
Canadian_Aboriginal: 'cans',
Carian: 'cari',
Cham: 'cham',
Cherokee: 'cher',
Coptic: 'copt',
Cypriot: 'cprt',
Cyrillic: 'cyrl',
Devanagari: [
'dev2',
'deva'
],
Deseret: 'dsrt',
Duployan: 'dupl',
Egyptian_Hieroglyphs: 'egyp',
Elbasan: 'elba',
Ethiopic: 'ethi',
Georgian: 'geor',
Glagolitic: 'glag',
Gothic: 'goth',
Grantha: 'gran',
Greek: 'grek',
Gujarati: [
'gjr2',
'gujr'
],
Gurmukhi: [
'gur2',
'guru'
],
Hangul: 'hang',
Han: 'hani',
Hanunoo: 'hano',
Hebrew: 'hebr',
Hiragana: 'hira',
Pahawh_Hmong: 'hmng',
Katakana_Or_Hiragana: 'hrkt',
Old_Italic: 'ital',
Javanese: 'java',
Kayah_Li: 'kali',
Katakana: 'kana',
Kharoshthi: 'khar',
Khmer: 'khmr',
Khojki: 'khoj',
Kannada: [
'knd2',
'knda'
],
Kaithi: 'kthi',
Tai_Tham: 'lana',
Lao: 'lao ',
Latin: 'latn',
Lepcha: 'lepc',
Limbu: 'limb',
Linear_A: 'lina',
Linear_B: 'linb',
Lisu: 'lisu',
Lycian: 'lyci',
Lydian: 'lydi',
Mahajani: 'mahj',
Mandaic: 'mand',
Manichaean: 'mani',
Mende_Kikakui: 'mend',
Meroitic_Cursive: 'merc',
Meroitic_Hieroglyphs: 'mero',
Malayalam: [
'mlm2',
'mlym'
],
Modi: 'modi',
Mongolian: 'mong',
Mro: 'mroo',
Meetei_Mayek: 'mtei',
Myanmar: [
'mym2',
'mymr'
],
Old_North_Arabian: 'narb',
Nabataean: 'nbat',
Nko: 'nko ',
Ogham: 'ogam',
Ol_Chiki: 'olck',
Old_Turkic: 'orkh',
Oriya: [
'ory2',
'orya'
],
Osmanya: 'osma',
Palmyrene: 'palm',
Pau_Cin_Hau: 'pauc',
Old_Permic: 'perm',
Phags_Pa: 'phag',
Inscriptional_Pahlavi: 'phli',
Psalter_Pahlavi: 'phlp',
Phoenician: 'phnx',
Miao: 'plrd',
Inscriptional_Parthian: 'prti',
Rejang: 'rjng',
Runic: 'runr',
Samaritan: 'samr',
Old_South_Arabian: 'sarb',
Saurashtra: 'saur',
Shavian: 'shaw',
Sharada: 'shrd',
Siddham: 'sidd',
Khudawadi: 'sind',
Sinhala: 'sinh',
Sora_Sompeng: 'sora',
Sundanese: 'sund',
Syloti_Nagri: 'sylo',
Syriac: 'syrc',
Tagbanwa: 'tagb',
Takri: 'takr',
Tai_Le: 'tale',
New_Tai_Lue: 'talu',
Tamil: [
'tml2',
'taml'
],
Tai_Viet: 'tavt',
Telugu: [
'tel2',
'telu'
],
Tifinagh: 'tfng',
Tagalog: 'tglg',
Thaana: 'thaa',
Thai: 'thai',
Tibetan: 'tibt',
Tirhuta: 'tirh',
Ugaritic: 'ugar',
Vai: 'vai ',
Warang_Citi: 'wara',
Old_Persian: 'xpeo',
Cuneiform: 'xsux',
Yi: 'yi ',
Inherited: 'zinh',
Common: 'zyyy',
Unknown: 'zzzz'
};
const $e38a1a895f6aeb54$var$OPENTYPE_SCRIPTS = {};
for(let script in $e38a1a895f6aeb54$var$UNICODE_SCRIPTS){
let tag = $e38a1a895f6aeb54$var$UNICODE_SCRIPTS[script];
if (Array.isArray(tag)) for (let t of tag)$e38a1a895f6aeb54$var$OPENTYPE_SCRIPTS[t] = script;
else $e38a1a895f6aeb54$var$OPENTYPE_SCRIPTS[tag] = script;
}
function $e38a1a895f6aeb54$export$b32f0b5f69d65e51(script) {
return $e38a1a895f6aeb54$var$UNICODE_SCRIPTS[script];
}
function $e38a1a895f6aeb54$export$ce50e82f12a827a4(tag) {
return $e38a1a895f6aeb54$var$OPENTYPE_SCRIPTS[tag];
}
function $e38a1a895f6aeb54$export$e5cb25e204fb8450(string) {
let len = string.length;
let idx = 0;
while(idx < len){
let code = string.charCodeAt(idx++);
// Check if this is a high surrogate
if (0xd800 <= code && code <= 0xdbff && idx < len) {
let next = string.charCodeAt(idx);
// Check if this is a low surrogate
if (0xdc00 <= next && next <= 0xdfff) {
idx++;
code = ((code & 0x3FF) << 10) + (next & 0x3FF) + 0x10000;
}
}
let script = (0, $gfJaN$unicodeproperties.getScript)(code);
if (script !== 'Common' && script !== 'Inherited' && script !== 'Unknown') return $e38a1a895f6aeb54$var$UNICODE_SCRIPTS[script];
}
return $e38a1a895f6aeb54$var$UNICODE_SCRIPTS.Unknown;
}
function $e38a1a895f6aeb54$export$16fab0757cfc223d(codePoints) {
for(let i = 0; i < codePoints.length; i++){
let codePoint = codePoints[i];
let script = (0, $gfJaN$unicodeproperties.getScript)(codePoint);
if (script !== 'Common' && script !== 'Inherited' && script !== 'Unknown') return $e38a1a895f6aeb54$var$UNICODE_SCRIPTS[script];
}
return $e38a1a895f6aeb54$var$UNICODE_SCRIPTS.Unknown;
}
// The scripts in this map are written from right to left
const $e38a1a895f6aeb54$var$RTL = {
arab: true,
hebr: true,
syrc: true,
thaa: true,
cprt: true,
khar: true,
phnx: true,
'nko ': true,
lydi: true,
avst: true,
armi: true,
phli: true,
prti: true,
sarb: true,
orkh: true,
samr: true,
mand: true,
merc: true,
mero: true,
// Unicode 7.0 (not listed on http://www.microsoft.com/typography/otspec/scripttags.htm)
mani: true,
mend: true,
nbat: true,
narb: true,
palm: true,
phlp: true // Psalter Pahlavi
};
function $e38a1a895f6aeb54$export$9fddb9d0dd7d8a54(script) {
if ($e38a1a895f6aeb54$var$RTL[script]) return 'rtl';
return 'ltr';
}
class $b19c79ec7a94fa39$export$2e2bcd8739ae039 {
/**
* The total advance width of the run.
* @type {number}
*/ get advanceWidth() {
let width = 0;
for (let position of this.positions)width += position.xAdvance;
return width;
}
/**
* The total advance height of the run.
* @type {number}
*/ get advanceHeight() {
let height = 0;
for (let position of this.positions)height += position.yAdvance;
return height;
}
/**
* The bounding box containing all glyphs in the run.
* @type {BBox}
*/ get bbox() {
let bbox = new (0, $0e2da1c4ce69e8ad$export$2e2bcd8739ae039);
let x = 0;
let y = 0;
for(let index = 0; index < this.glyphs.length; index++){
let glyph = this.glyphs[index];
let p = this.positions[index];
let b = glyph.bbox;
bbox.addPoint(b.minX + x + p.xOffset, b.minY + y + p.yOffset);
bbox.addPoint(b.maxX + x + p.xOffset, b.maxY + y + p.yOffset);
x += p.xAdvance;
y += p.yAdvance;
}
return bbox;
}
constructor(glyphs, features, script, language, direction){
/**
* An array of Glyph objects in the run
* @type {Glyph[]}
*/ this.glyphs = glyphs;
/**
* An array of GlyphPosition objects for each glyph in the run
* @type {GlyphPosition[]}
*/ this.positions = null;
/**
* The script that was requested for shaping. This was either passed in or detected automatically.
* @type {string}
*/ this.script = script;
/**
* The language requested for shaping, as passed in. If `null`, the default language for the
* script was used.
* @type {string}
*/ this.language = language || null;
/**
* The direction requested for shaping, as passed in (either ltr or rtl).
* If `null`, the default direction of the script is used.
* @type {string}
*/ this.direction = direction || $e38a1a895f6aeb54$export$9fddb9d0dd7d8a54(script);
/**
* The features requested during shaping. This is a combination of user
* specified features and features chosen by the shaper.
* @type {object}
*/ this.features = {};
// Convert features to an object
if (Array.isArray(features)) for (let tag of features)this.features[tag] = true;
else if (typeof features === 'object') this.features = features;
}
}
/**
* Represents positioning information for a glyph in a GlyphRun.
*/ class $9195cf1266c12ea5$export$2e2bcd8739ae039 {
constructor(xAdvance = 0, yAdvance = 0, xOffset = 0, yOffset = 0){
/**
* The amount to move the virtual pen in the X direction after rendering this glyph.
* @type {number}
*/ this.xAdvance = xAdvance;
/**
* The amount to move the virtual pen in the Y direction after rendering this glyph.
* @type {number}
*/ this.yAdvance = yAdvance;
/**
* The offset from the pen position in the X direction at which to render this glyph.
* @type {number}
*/ this.xOffset = xOffset;
/**
* The offset from the pen position in the Y direction at which to render this glyph.
* @type {number}
*/ this.yOffset = yOffset;
}
}
// see https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html
// and /System/Library/Frameworks/CoreText.framework/Versions/A/Headers/SFNTLayoutTypes.h on a Mac
const $2b7f887ebcb5888a$var$features = {
allTypographicFeatures: {
code: 0,
exclusive: false,
allTypeFeatures: 0
},
ligatures: {
code: 1,
exclusive: false,
requiredLigatures: 0,
commonLigatures: 2,
rareLigatures: 4,
// logos: 6
rebusPictures: 8,
diphthongLigatures: 10,
squaredLigatures: 12,
abbrevSquaredLigatures: 14,
symbolLigatures: 16,
contextualLigatures: 18,
historicalLigatures: 20
},
cursiveConnection: {
code: 2,
exclusive: true,
unconnected: 0,
partiallyConnected: 1,
cursive: 2
},
letterCase: {
code: 3,
exclusive: true
},
// upperAndLowerCase: 0 # deprecated
// allCaps: 1 # deprecated
// allLowerCase: 2 # deprecated
// smallCaps: 3 # deprecated
// initialCaps: 4 # deprecated
// initialCapsAndSmallCaps: 5 # deprecated
verticalSubstitution: {
code: 4,
exclusive: false,
substituteVerticalForms: 0
},
linguisticRearrangement: {
code: 5,
exclusive: false,
linguisticRearrangement: 0
},
numberSpacing: {
code: 6,
exclusive: true,
monospacedNumbers: 0,
proportionalNumbers: 1,
thirdWidthNumbers: 2,
quarterWidthNumbers: 3
},
smartSwash: {
code: 8,
exclusive: false,
wordInitialSwashes: 0,
wordFinalSwashes: 2,
// lineInitialSwashes: 4
// lineFinalSwashes: 6
nonFinalSwashes: 8
},
diacritics: {
code: 9,
exclusive: true,
showDiacritics: 0,
hideDiacritics: 1,
decomposeDiacritics: 2
},
verticalPosition: {
code: 10,
exclusive: true,
normalPosition: 0,
superiors: 1,
inferiors: 2,
ordinals: 3,
scientificInferiors: 4
},
fractions: {
code: 11,
exclusive: true,
noFractions: 0,
verticalFractions: 1,
diagonalFractions: 2
},
overlappingCharacters: {
code: 13,
exclusive: false,
preventOverlap: 0
},
typographicExtras: {
code: 14,
exclusive: false,
// hyphensToEmDash: 0
// hyphenToEnDash: 2
slashedZero: 4
},
// formInterrobang: 6
// smartQuotes: 8
// periodsToEllipsis: 10
mathematicalExtras: {
code: 15,
exclusive: false,
// hyphenToMinus: 0
// asteristoMultiply: 2
// slashToDivide: 4
// inequalityLigatures: 6
// exponents: 8
mathematicalGreek: 10
},
ornamentSets: {
code: 16,
exclusive: true,
noOrnaments: 0,
dingbats: 1,
piCharacters: 2,
fleurons: 3,
decorativeBorders: 4,
internationalSymbols: 5,
mathSymbols: 6
},
characterAlternatives: {
code: 17,
exclusive: true,
noAlternates: 0
},
// user defined options
designComplexity: {
code: 18,
exclusive: true,
designLevel1: 0,
designLevel2: 1,
designLevel3: 2,
designLevel4: 3,
designLevel5: 4
},
styleOptions: {
code: 19,
exclusive: true,
noStyleOptions: 0,
displayText: 1,
engravedText: 2,
illuminatedCaps: 3,
titlingCaps: 4,
tallCaps: 5
},
characterShape: {
code: 20,
exclusive: true,
traditionalCharacters: 0,
simplifiedCharacters: 1,
JIS1978Characters: 2,
JIS1983Characters: 3,
JIS1990Characters: 4,
traditionalAltOne: 5,
traditionalAltTwo: 6,
traditionalAltThree: 7,
traditionalAltFour: 8,
traditionalAltFive: 9,
expertCharacters: 10,
JIS2004Characters: 11,
hojoCharacters: 12,
NLCCharacters: 13,
traditionalNamesCharacters: 14
},
numberCase: {
code: 21,
exclusive: true,
lowerCaseNumbers: 0,
upperCaseNumbers: 1
},
textSpacing: {
code: 22,
exclusive: true,
proportionalText: 0,
monospacedText: 1,
halfWidthText: 2,
thirdWidthText: 3,
quarterWidthText: 4,
altProportionalText: 5,
altHalfWidthText: 6
},
transliteration: {
code: 23,
exclusive: true,
noTransliteration: 0
},
// hanjaToHangul: 1
// hiraganaToKatakana: 2
// katakanaToHiragana: 3
// kanaToRomanization: 4
// romanizationToHiragana: 5
// romanizationToKatakana: 6
// hanjaToHangulAltOne: 7
// hanjaToHangulAltTwo: 8
// hanjaToHangulAltThree: 9
annotation: {
code: 24,
exclusive: true,
noAnnotation: 0,
boxAnnotation: 1,
roundedBoxAnnotation: 2,
circleAnnotation: 3,
invertedCircleAnnotation: 4,
parenthesisAnnotation: 5,
periodAnnotation: 6,
romanNumeralAnnotation: 7,
diamondAnnotation: 8,
invertedBoxAnnotation: 9,
invertedRoundedBoxAnnotation: 10
},
kanaSpacing: {
code: 25,
exclusive: true,
fullWidthKana: 0,
proportionalKana: 1
},
ideographicSpacing: {
code: 26,
exclusive: true,
fullWidthIdeographs: 0,
proportionalIdeographs: 1,
halfWidthIdeographs: 2
},
unicodeDecomposition: {
code: 27,
exclusive: false,
canonicalComposition: 0,
compatibilityComposition: 2,
transcodingComposition: 4
},
rubyKana: {
code: 28,
exclusive: false,
// noRubyKana: 0 # deprecated - use rubyKanaOff instead
// rubyKana: 1 # deprecated - use rubyKanaOn instead
rubyKana: 2
},
CJKSymbolAlternatives: {
code: 29,
exclusive: true,
noCJKSymbolAlternatives: 0,
CJKSymbolAltOne: 1,
CJKSymbolAltTwo: 2,
CJKSymbolAltThree: 3,
CJKSymbolAltFour: 4,
CJKSymbolAltFive: 5
},
ideographicAlternatives: {
code: 30,
exclusive: true,
noIdeographicAlternatives: 0,
ideographicAltOne: 1,
ideographicAltTwo: 2,
ideographicAltThree: 3,
ideographicAltFour: 4,
ideographicAltFive: 5
},
CJKVerticalRomanPlacement: {
code: 31,
exclusive: true,
CJKVerticalRomanCentered: 0,
CJKVerticalRomanHBaseline: 1
},
italicCJKRoman: {
code: 32,
exclusive: false,
// noCJKItalicRoman: 0 # deprecated - use CJKItalicRomanOff instead
// CJKItalicRoman: 1 # deprecated - use CJKItalicRomanOn instead
CJKItalicRoman: 2
},
caseSensitiveLayout: {
code: 33,
exclusive: false,
caseSensitiveLayout: 0,
caseSensitiveSpacing: 2
},
alternateKana: {
code: 34,
exclusive: false,
alternateHorizKana: 0,
alternateVertKana: 2
},
stylisticAlternatives: {
code: 35,
exclusive: false,
noStylisticAlternates: 0,
stylisticAltOne: 2,
stylisticAltTwo: 4,
stylisticAltThree: 6,
stylisticAltFour: 8,
stylisticAltFive: 10,
stylisticAltSix: 12,
stylisticAltSeven: 14,
stylisticAltEight: 16,
stylisticAltNine: 18,
stylisticAltTen: 20,
stylisticAltEleven: 22,
stylisticAltTwelve: 24,
stylisticAltThirteen: 26,
stylisticAltFourteen: 28,
stylisticAltFifteen: 30,
stylisticAltSixteen: 32,
stylisticAltSeventeen: 34,
stylisticAltEighteen: 36,
stylisticAltNineteen: 38,
stylisticAltTwenty: 40
},
contextualAlternates: {
code: 36,
exclusive: false,
contextualAlternates: 0,
swashAlternates: 2,
contextualSwashAlternates: 4
},
lowerCase: {
code: 37,
exclusive: true,
defaultLowerCase: 0,
lowerCaseSmallCaps: 1,
lowerCasePetiteCaps: 2
},
upperCase: {
code: 38,
exclusive: true,
defaultUpperCase: 0,
upperCaseSmallCaps: 1,
upperCasePetiteCaps: 2
},
languageTag: {
code: 39,
exclusive: true
},
CJKRomanSpacing: {
code: 103,
exclusive: true,
halfWidthCJKRoman: 0,
proportionalCJKRoman: 1,
defaultCJKRoman: 2,
fullWidthCJKRoman: 3
}
};
const $2b7f887ebcb5888a$var$feature = (name, selector)=>[
$2b7f887ebcb5888a$var$features[name].code,
$2b7f887ebcb5888a$var$features[name][selector]
];
const $2b7f887ebcb5888a$var$OTMapping = {
rlig: $2b7f887ebcb5888a$var$feature('ligatures', 'requiredLigatures'),
clig: $2b7f887ebcb5888a$var$feature('ligatures', 'contextualLigatures'),
dlig: $2b7f887ebcb5888a$var$feature('ligatures', 'rareLigatures'),
hlig: $2b7f887ebcb5888a$var$feature('ligatures', 'historicalLigatures'),
liga: $2b7f887ebcb5888a$var$feature('ligatures', 'commonLigatures'),
hist: $2b7f887ebcb5888a$var$feature('ligatures', 'historicalLigatures'),
smcp: $2b7f887ebcb5888a$var$feature('lowerCase', 'lowerCaseSmallCaps'),
pcap: $2b7f887ebcb5888a$var$feature('lowerCase', 'lowerCasePetiteCaps'),
frac: $2b7f887ebcb5888a$var$feature('fractions', 'diagonalFractions'),
dnom: $2b7f887ebcb5888a$var$feature('fractions', 'diagonalFractions'),
numr: $2b7f887ebcb5888a$var$feature('fractions', 'diagonalFractions'),
afrc: $2b7f887ebcb5888a$var$feature('fractions', 'verticalFractions'),
// aalt
// abvf, abvm, abvs, akhn, blwf, blwm, blws, cfar, cjct, cpsp, falt, isol, jalt, ljmo, mset?
// ltra, ltrm, nukt, pref, pres, pstf, psts, rand, rkrf, rphf, rtla, rtlm, size, tjmo, tnum?
// unic, vatu, vhal, vjmo, vpal, vrt2
// dist -> trak table?
// kern, vkrn -> kern table
// lfbd + opbd + rtbd -> opbd table?
// mark, mkmk -> acnt table?
// locl -> languageTag + ltag table
case: $2b7f887ebcb5888a$var$feature('caseSensitiveLayout', 'caseSensitiveLayout'),
ccmp: $2b7f887ebcb5888a$var$feature('unicodeDecomposition', 'canonicalComposition'),
cpct: $2b7f887ebcb5888a$var$feature('CJKVerticalRomanPlacement', 'CJKVerticalRomanCentered'),
valt: $2b7f887ebcb5888a$var$feature('CJKVerticalRomanPlacement', 'CJKVerticalRomanCentered'),
swsh: $2b7f887ebcb5888a$var$feature('contextualAlternates', 'swashAlternates'),
cswh: $2b7f887ebcb5888a$var$feature('contextualAlternates', 'contextualSwashAlternates'),
curs: $2b7f887ebcb5888a$var$feature('cursiveConnection', 'cursive'),
c2pc: $2b7f887ebcb5888a$var$feature('upperCase', 'upperCasePetiteCaps'),
c2sc: $2b7f887ebcb5888a$var$feature('upperCase', 'upperCaseSmallCaps'),
init: $2b7f887ebcb5888a$var$feature('smartSwash', 'wordInitialSwashes'),
fin2: $2b7f887ebcb5888a$var$feature('smartSwash', 'wordFinalSwashes'),
medi: $2b7f887ebcb5888a$var$feature('smartSwash', 'nonFinalSwashes'),
med2: $2b7f887ebcb5888a$var$feature('smartSwash', 'nonFinalSwashes'),
fin3: $2b7f887ebcb5888a$var$feature('smartSwash', 'wordFinalSwashes'),
fina: $2b7f887ebcb5888a$var$feature('smartSwash', 'wordFinalSwashes'),
pkna: $2b7f887ebcb5888a$var$feature('kanaSpacing', 'proportionalKana'),
half: $2b7f887ebcb5888a$var$feature('textSpacing', 'halfWidthText'),
halt: $2b7f887ebcb5888a$var$feature('textSpacing', 'altHalfWidthText'),
hkna: $2b7f887ebcb5888a$var$feature('alternateKana', 'alternateHorizKana'),
vkna: $2b7f887ebcb5888a$var$feature('alternateKana', 'alternateVertKana'),
// hngl: feature 'transliteration', 'hanjaToHangulSelector' # deprecated
ital: $2b7f887ebcb5888a$var$feature('italicCJKRoman', 'CJKItalicRoman'),
lnum: $2b7f887ebcb5888a$var$feature('numberCase', 'upperCaseNumbers'),
onum: $2b7f887ebcb5888a$var$feature('numberCase', 'lowerCaseNumbers'),
mgrk: $2b7f887ebcb5888a$var$feature('mathematicalExtras', 'mathematicalGreek'),
// nalt: not enough info. what type of annotation?
// ornm: ditto, which ornament style?
calt: $2b7f887ebcb5888a$var$feature('contextualAlternates', 'contextualAlternates'),
vrt2: $2b7f887ebcb5888a$var$feature('verticalSubstitution', 'substituteVerticalForms'),
vert: $2b7f887ebcb5888a$var$feature('verticalSubstitution', 'substituteVerticalForms'),
tnum: $2b7f887ebcb5888a$var$feature('numberSpacing', 'monospacedNumbers'),
pnum: $2b7f887ebcb5888a$var$feature('numberSpacing', 'proportionalNumbers'),
sups: $2b7f887ebcb5888a$var$feature('verticalPosition', 'superiors'),
subs: $2b7f887ebcb5888a$var$feature('verticalPosition', 'inferiors'),
ordn: $2b7f887ebcb5888a$var$feature('verticalPosition', 'ordinals'),
pwid: $2b7f887ebcb5888a$var$feature('textSpacing', 'proportionalText'),
hwid: $2b7f887ebcb5888a$var$feature('textSpacing', 'halfWidthText'),
qwid: $2b7f887ebcb5888a$var$feature('textSpacing', 'quarterWidthText'),
twid: $2b7f887ebcb5888a$var$feature('textSpacing', 'thirdWidthText'),
fwid: $2b7f887ebcb5888a$var$feature('textSpacing', 'proportionalText'),
palt: $2b7f887ebcb5888a$var$feature('textSpacing', 'altProportionalText'),
trad: $2b7f887ebcb5888a$var$feature('characterShape', 'traditionalCharacters'),
smpl: $2b7f887ebcb5888a$var$feature('characterShape', 'simplifiedCharacters'),
jp78: $2b7f887ebcb5888a$var$feature('characterShape', 'JIS1978Characters'),
jp83: $2b7f887ebcb5888a$var$feature('characterShape', 'JIS1983Characters'),
jp90: $2b7f887ebcb5888a$var$feature('characterShape', 'JIS1990Characters'),
jp04: $2b7f887ebcb5888a$var$feature('characterShape', 'JIS2004Characters'),
expt: $2b7f887ebcb5888a$var$feature('characterShape', 'expertCharacters'),
hojo: $2b7f887ebcb5888a$var$feature('characterShape', 'hojoCharacters'),
nlck: $2b7f887ebcb5888a$var$feature('characterShape', 'NLCCharacters'),
tnam: $2b7f887ebcb5888a$var$feature('characterShape', 'traditionalNamesCharacters'),
ruby: $2b7f887ebcb5888a$var$feature('rubyKana', 'rubyKana'),
titl: $2b7f887ebcb5888a$var$feature('styleOptions', 'titlingCaps'),
zero: $2b7f887ebcb5888a$var$feature('typographicExtras', 'slashedZero'),
ss01: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltOne'),
ss02: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltTwo'),
ss03: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltThree'),
ss04: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltFour'),
ss05: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltFive'),
ss06: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltSix'),
ss07: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltSeven'),
ss08: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltEight'),
ss09: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltNine'),
ss10: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltTen'),
ss11: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltEleven'),
ss12: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltTwelve'),
ss13: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltThirteen'),
ss14: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltFourteen'),
ss15: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltFifteen'),
ss16: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltSixteen'),
ss17: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltSeventeen'),
ss18: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltEighteen'),
ss19: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltNineteen'),
ss20: $2b7f887ebcb5888a$var$feature('stylisticAlternatives', 'stylisticAltTwenty')
};
// salt: feature 'stylisticAlternatives', 'stylisticAltOne' # hmm, which one to choose
// Add cv01-cv99 features
for(let i = 1; i <= 99; i++)$2b7f887ebcb5888a$var$OTMapping[`cv${`00${i}`.slice(-2)}`] = [
$2b7f887ebcb5888a$var$features.characterAlternatives.code,
i
];
// create inverse mapping
let $2b7f887ebcb5888a$var$AATMapping = {};
for(let ot in $2b7f887ebcb5888a$var$OTMapping){
let aat = $2b7f887ebcb5888a$var$OTMapping[ot];
if ($2b7f887ebcb5888a$var$AATMapping[aat[0]] == null) $2b7f887ebcb5888a$var$AATMapping[aat[0]] = {};
$2b7f887ebcb5888a$var$AATMapping[aat[0]][aat[1]] = ot;
}
function $2b7f887ebcb5888a$export$b813f7d2a1677c16(features) {
let res = {};
for(let k in features){
let r;
if (r = $2b7f887ebcb5888a$var$OTMapping[k]) {
if (res[r[0]] == null) res[r[0]] = {};
res[r[0]][r[1]] = features[k];
}
}
return res;
}
// Maps strings in a [featureType, featureSetting]
// to their equivalent number codes
function $2b7f887ebcb5888a$var$mapFeatureStrings(f) {
let [type, setting] = f;
if (isNaN(type)) var typeCode = $2b7f887ebcb5888a$var$features[type] && $2b7f887ebcb5888a$var$features[type].code;
else var typeCode = type;
if (isNaN(setting)) var settingCode = $2b7f887ebcb5888a$var$features[type] && $2b7f887ebcb5888a$var$features[type][setting];
else var settingCode = setting;
return [
typeCode,
settingCode
];
}
function $2b7f887ebcb5888a$export$bd6df347a4f391c4(features) {
let res = {};
if (Array.isArray(features)) for(let k = 0; k < features.length; k++){
let r;
let f = $2b7f887ebcb5888a$var$mapFeatureStrings(features[k]);
if (r = $2b7f887ebcb5888a$var$AATMapping[f[0]] && $2b7f887ebcb5888a$var$AATMapping[f[0]][f[1]]) res[r] = true;
}
else if (typeof features === 'object') for(let type in features){
let feature = features[type];
for(let setting in feature){
let r;
let f = $2b7f887ebcb5888a$var$mapFeatureStrings([
type,
setting
]);
if (feature[setting] && (r = $2b7f887ebcb5888a$var$AATMapping[f[0]] && $2b7f887ebcb5888a$var$AATMapping[f[0]][f[1]])) res[r] = true;
}
}
return Object.keys(res);
}
class $f3d63ae925545400$export$2e2bcd8739ae039 {
lookup(glyph) {
switch(this.table.version){
case 0:
return this.table.values.getItem(glyph);
case 2:
case 4:
{
let min = 0;
let max = this.table.binarySearchHeader.nUnits - 1;
while(min <= max){
var mid = min + max >> 1;
var seg = this.table.segments[mid];
// special end of search value
if (seg.firstGlyph === 0xffff) return null;
if (glyph < seg.firstGlyph) max = mid - 1;
else if (glyph > seg.lastGlyph) min = mid + 1;
else {
if (this.table.version === 2) return seg.value;
else return seg.values[glyph - seg.firstGlyph];
}
}
return null;
}
case 6:
{
let min = 0;
let max = this.table.binarySearchHeader.nUnits - 1;
while(min <= max){
var mid = min + max >> 1;
var seg = this.table.segments[mid];
// special end of search value
if (seg.glyph === 0xffff) return null;
if (glyph < seg.glyph) max = mid - 1;
else if (glyph > seg.glyph) min = mid + 1;
else return seg.value;
}
return null;
}
case 8:
return this.table.values[glyph - this.table.firstGlyph];
default:
throw new Error(`Unknown lookup table format: ${this.table.version}`);
}
}
glyphsForValue(classValue) {
let res = [];
switch(this.table.version){
case 2:
case 4:
for (let segment of this.table.segments)if (this.table.version === 2 && segment.value === classValue) res.push(...(0, $66a5b9fb5318558a$export$d02631cccf789723)(segment.firstGlyph, segment.lastGlyph + 1));
else {
for(let index = 0; index < segment.values.length; index++)if (segment.values[index] === classValue) res.push(segment.firstGlyph + index);
}
break;
case 6:
for (let segment of this.table.segments)if (segment.value === classValue) res.push(segment.glyph);
break;
case 8:
for(let i = 0; i < this.table.values.length; i++)if (this.table.values[i] === classValue) res.push(this.table.firstGlyph + i);
break;
default:
throw new Error(`Unknown lookup table format: ${this.table.version}`);
}
return res;
}
constructor(table){
this.table = table;
}
}
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $f3d63ae925545400$export$2e2bcd8739ae039.prototype, "glyphsForValue", null);
const $860c6347bb941b91$var$START_OF_TEXT_STATE = 0;
const $860c6347bb941b91$var$START_OF_LINE_STATE = 1;
const $860c6347bb941b91$var$END_OF_TEXT_CLASS = 0;
const $860c6347bb941b91$var$OUT_OF_BOUNDS_CLASS = 1;
const $860c6347bb941b91$var$DELETED_GLYPH_CLASS = 2;
const $860c6347bb941b91$var$END_OF_LINE_CLASS = 3;
const $860c6347bb941b91$var$DONT_ADVANCE = 0x4000;
class $860c6347bb941b91$export$2e2bcd8739ae039 {
process(glyphs, reverse, processEntry) {
let currentState = $860c6347bb941b91$var$START_OF_TEXT_STATE; // START_OF_LINE_STATE is used for kashida glyph insertions sometimes I think?
let index = reverse ? glyphs.length - 1 : 0;
let dir = reverse ? -1 : 1;
while(dir === 1 && index <= glyphs.length || dir === -1 && index >= -1){
let glyph = null;
let classCode = $860c6347bb941b91$var$OUT_OF_BOUNDS_CLASS;
let shouldAdvance = true;
if (index === glyphs.length || index === -1) classCode = $860c6347bb941b91$var$END_OF_TEXT_CLASS;
else {
glyph = glyphs[index];
if (glyph.id === 0xffff) classCode = $860c6347bb941b91$var$DELETED_GLYPH_CLASS;
else {
classCode = this.lookupTable.lookup(glyph.id);
if (classCode == null) classCode = $860c6347bb941b91$var$OUT_OF_BOUNDS_CLASS;
}
}
let row = this.stateTable.stateArray.getItem(currentState);
let entryIndex = row[classCode];
let entry = this.stateTable.entryTable.getItem(entryIndex);
if (classCode !== $860c6347bb941b91$var$END_OF_TEXT_CLASS && classCode !== $860c6347bb941b91$var$DELETED_GLYPH_CLASS) {
processEntry(glyph, entry, index);
shouldAdvance = !(entry.flags & $860c6347bb941b91$var$DONT_ADVANCE);
}
currentState = entry.newState;
if (shouldAdvance) index += dir;
}
return glyphs;
}
/**
* Performs a depth-first traversal of the glyph strings
* represented by the state machine.
*/ traverse(opts, state = 0, visited = new Set) {
if (visited.has(state)) return;
visited.add(state);
let { nClasses: nClasses, stateArray: stateArray, entryTable: entryTable } = this.stateTable;
let row = stateArray.getItem(state);
// Skip predefined classes
for(let classCode = 4; classCode < nClasses; classCode++){
let entryIndex = row[classCode];
let entry = entryTable.getItem(entryIndex);
// Try all glyphs in the class
for (let glyph of this.lookupTable.glyphsForValue(classCode)){
if (opts.enter) opts.enter(glyph, entry);
if (entry.newState !== 0) this.traverse(opts, entry.newState, visited);
if (opts.exit) opts.exit(glyph, entry);
}
}
}
constructor(stateTable){
this.stateTable = stateTable;
this.lookupTable = new (0, $f3d63ae925545400$export$2e2bcd8739ae039)(stateTable.classTable);
}
}
// indic replacement flags
const $99be642f82069918$var$MARK_FIRST = 0x8000;
const $99be642f82069918$var$MARK_LAST = 0x2000;
const $99be642f82069918$var$VERB = 0x000F;
// contextual substitution and glyph insertion flag
const $99be642f82069918$var$SET_MARK = 0x8000;
// ligature entry flags
const $99be642f82069918$var$SET_COMPONENT = 0x8000;
const $99be642f82069918$var$PERFORM_ACTION = 0x2000;
// ligature action masks
const $99be642f82069918$var$LAST_MASK = 0x80000000;
const $99be642f82069918$var$STORE_MASK = 0x40000000;
const $99be642f82069918$var$OFFSET_MASK = 0x3FFFFFFF;
const $99be642f82069918$var$VERTICAL_ONLY = 0x800000;
const $99be642f82069918$var$REVERSE_DIRECTION = 0x400000;
const $99be642f82069918$var$HORIZONTAL_AND_VERTICAL = 0x200000;
// glyph insertion flags
const $99be642f82069918$var$CURRENT_IS_KASHIDA_LIKE = 0x2000;
const $99be642f82069918$var$MARKED_IS_KASHIDA_LIKE = 0x1000;
const $99be642f82069918$var$CURRENT_INSERT_BEFORE = 0x0800;
const $99be642f82069918$var$MARKED_INSERT_BEFORE = 0x0400;
const $99be642f82069918$var$CURRENT_INSERT_COUNT = 0x03E0;
const $99be642f82069918$var$MARKED_INSERT_COUNT = 0x001F;
class $99be642f82069918$export$2e2bcd8739ae039 {
// Processes an array of glyphs and applies the specified features
// Features should be in the form of {featureType:{featureSetting:boolean}}
process(glyphs, features = {}) {
for (let chain of this.morx.chains){
let flags = chain.defaultFlags;
// enable/disable the requested features
for (let feature of chain.features){
let f;
if (f = features[feature.featureType]) {
if (f[feature.featureSetting]) {
flags &= feature.disableFlags;
flags |= feature.enableFlags;
} else if (f[feature.featureSetting] === false) {
flags |= ~feature.disableFlags;
flags &= ~feature.enableFlags;
}
}
}
for (let subtable of chain.subtables)if (subtable.subFeatureFlags & flags) this.processSubtable(subtable, glyphs);
}
// remove deleted glyphs
let index = glyphs.length - 1;
while(index >= 0){
if (glyphs[index].id === 0xffff) glyphs.splice(index, 1);
index--;
}
return glyphs;
}
processSubtable(subtable, glyphs) {
this.subtable = subtable;
this.glyphs = glyphs;
if (this.subtable.type === 4) {
this.processNoncontextualSubstitutions(this.subtable, this.glyphs);
return;
}
this.ligatureStack = [];
this.markedGlyph = null;
this.firstGlyph = null;
this.lastGlyph = null;
this.markedIndex = null;
let stateMachine = this.getStateMachine(subtable);
let process = this.getProcessor();
let reverse = !!(this.subtable.coverage & $99be642f82069918$var$REVERSE_DIRECTION);
return stateMachine.process(this.glyphs, reverse, process);
}
getStateMachine(subtable) {
return new (0, $860c6347bb941b91$export$2e2bcd8739ae039)(subtable.table.stateTable);
}
getProcessor() {
switch(this.subtable.type){
case 0:
return this.processIndicRearragement;
case 1:
return this.processContextualSubstitution;
case 2:
return this.processLigature;
case 4:
return this.processNoncontextualSubstitutions;
case 5:
return this.processGlyphInsertion;
default:
throw new Error(`Invalid morx subtable type: ${this.subtable.type}`);
}
}
processIndicRearragement(glyph, entry, index) {
if (entry.flags & $99be642f82069918$var$MARK_FIRST) this.firstGlyph = index;
if (entry.flags & $99be642f82069918$var$MARK_LAST) this.lastGlyph = index;
$99be642f82069918$var$reorderGlyphs(this.glyphs, entry.flags & $99be642f82069918$var$VERB, this.firstGlyph, this.lastGlyph);
}
processContextualSubstitution(glyph, entry, index) {
let subsitutions = this.subtable.table.substitutionTable.items;
if (entry.markIndex !== 0xffff) {
let lookup = subsitutions.getItem(entry.markIndex);
let lookupTable = new (0, $f3d63ae925545400$export$2e2bcd8739ae039)(lookup);
glyph = this.glyphs[this.markedGlyph];
var gid = lookupTable.lookup(glyph.id);
if (gid) this.glyphs[this.markedGlyph] = this.font.getGlyph(gid, glyph.codePoints);
}
if (entry.currentIndex !== 0xffff) {
let lookup = subsitutions.getItem(entry.currentIndex);
let lookupTable = new (0, $f3d63ae925545400$export$2e2bcd8739ae039)(lookup);
glyph = this.glyphs[index];
var gid = lookupTable.lookup(glyph.id);
if (gid) this.glyphs[index] = this.font.getGlyph(gid, glyph.codePoints);
}
if (entry.flags & $99be642f82069918$var$SET_MARK) this.markedGlyph = index;
}
processLigature(glyph, entry, index) {
if (entry.flags & $99be642f82069918$var$SET_COMPONENT) this.ligatureStack.push(index);
if (entry.flags & $99be642f82069918$var$PERFORM_ACTION) {
let actions = this.subtable.table.ligatureActions;
let components = this.subtable.table.components;
let ligatureList = this.subtable.table.ligatureList;
let actionIndex = entry.action;
let last = false;
let ligatureIndex = 0;
let codePoints = [];
let ligatureGlyphs = [];
while(!last){
let componentGlyph = this.ligatureStack.pop();
codePoints.unshift(...this.glyphs[componentGlyph].codePoints);
let action = actions.getItem(actionIndex++);
last = !!(action & $99be642f82069918$var$LAST_MASK);
let store = !!(action & $99be642f82069918$var$STORE_MASK);
let offset = (action & $99be642f82069918$var$OFFSET_MASK) << 2 >> 2; // sign extend 30 to 32 bits
offset += this.glyphs[componentGlyph].id;
let component = components.getItem(offset);
ligatureIndex += component;
if (last || store) {
let ligatureEntry = ligatureList.getItem(ligatureIndex);
this.glyphs[componentGlyph] = this.font.getGlyph(ligatureEntry, codePoints);
ligatureGlyphs.push(componentGlyph);
ligatureIndex = 0;
codePoints = [];
} else this.glyphs[componentGlyph] = this.font.getGlyph(0xffff);
}
// Put ligature glyph indexes back on the stack
this.ligatureStack.push(...ligatureGlyphs);
}
}
processNoncontextualSubstitutions(subtable, glyphs, index) {
let lookupTable = new (0, $f3d63ae925545400$export$2e2bcd8739ae039)(subtable.table.lookupTable);
for(index = 0; index < glyphs.length; index++){
let glyph = glyphs[index];
if (glyph.id !== 0xffff) {
let gid = lookupTable.lookup(glyph.id);
if (gid) glyphs[index] = this.font.getGlyph(gid, glyph.codePoints);
}
}
}
_insertGlyphs(glyphIndex, insertionActionIndex, count, isBefore) {
let insertions = [];
while(count--){
let gid = this.subtable.table.insertionActions.getItem(insertionActionIndex++);
insertions.push(this.font.getGlyph(gid));
}
if (!isBefore) glyphIndex++;
this.glyphs.splice(glyphIndex, 0, ...insertions);
}
processGlyphInsertion(glyph, entry, index) {
if (entry.flags & $99be642f82069918$var$SET_MARK) this.markedIndex = index;
if (entry.markedInsertIndex !== 0xffff) {
let count = (entry.flags & $99be642f82069918$var$MARKED_INSERT_COUNT) >>> 5;
let isBefore = !!(entry.flags & $99be642f82069918$var$MARKED_INSERT_BEFORE);
this._insertGlyphs(this.markedIndex, entry.markedInsertIndex, count, isBefore);
}
if (entry.currentInsertIndex !== 0xffff) {
let count = (entry.flags & $99be642f82069918$var$CURRENT_INSERT_COUNT) >>> 5;
let isBefore = !!(entry.flags & $99be642f82069918$var$CURRENT_INSERT_BEFORE);
this._insertGlyphs(index, entry.currentInsertIndex, count, isBefore);
}
}
getSupportedFeatures() {
let features = [];
for (let chain of this.morx.chains)for (let feature of chain.features)features.push([
feature.featureType,
feature.featureSetting
]);
return features;
}
generateInputs(gid) {
if (!this.inputCache) this.generateInputCache();
return this.inputCache[gid] || [];
}
generateInputCache() {
this.inputCache = {};
for (let chain of this.morx.chains){
let flags = chain.defaultFlags;
for (let subtable of chain.subtables)if (subtable.subFeatureFlags & flags) this.generateInputsForSubtable(subtable);
}
}
generateInputsForSubtable(subtable) {
// Currently, only supporting ligature subtables.
if (subtable.type !== 2) return;
let reverse = !!(subtable.coverage & $99be642f82069918$var$REVERSE_DIRECTION);
if (reverse) throw new Error('Reverse subtable, not supported.');
this.subtable = subtable;
this.ligatureStack = [];
let stateMachine = this.getStateMachine(subtable);
let process = this.getProcessor();
let input = [];
let stack = [];
this.glyphs = [];
stateMachine.traverse({
enter: (glyph, entry)=>{
let glyphs = this.glyphs;
stack.push({
glyphs: glyphs.slice(),
ligatureStack: this.ligatureStack.slice()
});
// Add glyph to input and glyphs to process.
let g = this.font.getGlyph(glyph);
input.push(g);
glyphs.push(input[input.length - 1]);
// Process ligature substitution
process(glyphs[glyphs.length - 1], entry, glyphs.length - 1);
// Add input to result if only one matching (non-deleted) glyph remains.
let count = 0;
let found = 0;
for(let i = 0; i < glyphs.length && count <= 1; i++)if (glyphs[i].id !== 0xffff) {
count++;
found = glyphs[i].id;
}
if (count === 1) {
let result = input.map((g)=>g.id);
let cache = this.inputCache[found];
if (cache) cache.push(result);
else this.inputCache[found] = [
result
];
}
},
exit: ()=>{
({ glyphs: this.glyphs, ligatureStack: this.ligatureStack } = stack.pop());
input.pop();
}
});
}
constructor(font){
this.processIndicRearragement = this.processIndicRearragement.bind(this);
this.processContextualSubstitution = this.processContextualSubstitution.bind(this);
this.processLigature = this.processLigature.bind(this);
this.processNoncontextualSubstitutions = this.processNoncontextualSubstitutions.bind(this);
this.processGlyphInsertion = this.processGlyphInsertion.bind(this);
this.font = font;
this.morx = font.morx;
this.inputCache = null;
}
}
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $99be642f82069918$export$2e2bcd8739ae039.prototype, "getStateMachine", null);
// swaps the glyphs in rangeA with those in rangeB
// reverse the glyphs inside those ranges if specified
// ranges are in [offset, length] format
function $99be642f82069918$var$swap(glyphs, rangeA, rangeB, reverseA = false, reverseB = false) {
let end = glyphs.splice(rangeB[0] - (rangeB[1] - 1), rangeB[1]);
if (reverseB) end.reverse();
let start = glyphs.splice(rangeA[0], rangeA[1], ...end);
if (reverseA) start.reverse();
glyphs.splice(rangeB[0] - (rangeA[1] - 1), 0, ...start);
return glyphs;
}
function $99be642f82069918$var$reorderGlyphs(glyphs, verb, firstGlyph, lastGlyph) {
let length = lastGlyph - firstGlyph + 1;
switch(verb){
case 0:
return glyphs;
case 1:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
1
], [
lastGlyph,
0
]);
case 2:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
0
], [
lastGlyph,
1
]);
case 3:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
1
], [
lastGlyph,
1
]);
case 4:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
0
]);
case 5:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
0
], true, false);
case 6:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
0
], [
lastGlyph,
2
]);
case 7:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
0
], [
lastGlyph,
2
], false, true);
case 8:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
1
], [
lastGlyph,
2
]);
case 9:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
1
], [
lastGlyph,
2
], false, true);
case 10:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
1
]);
case 11:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
1
], true, false);
case 12:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
2
]);
case 13:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
2
], true, false);
case 14:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
2
], false, true);
case 15:
return $99be642f82069918$var$swap(glyphs, [
firstGlyph,
2
], [
lastGlyph,
2
], true, true);
default:
throw new Error(`Unknown verb: ${verb}`);
}
}
class $860fcbd64bc12fbc$export$2e2bcd8739ae039 {
substitute(glyphRun) {
// AAT expects the glyphs to be in visual order prior to morx processing,
// so reverse the glyphs if the script is right-to-left.
if (glyphRun.direction === 'rtl') glyphRun.glyphs.reverse();
this.morxProcessor.process(glyphRun.glyphs, $2b7f887ebcb5888a$export$b813f7d2a1677c16(glyphRun.features));
}
getAvailableFeatures(script, language) {
return $2b7f887ebcb5888a$export$bd6df347a4f391c4(this.morxProcessor.getSupportedFeatures());
}
stringsForGlyph(gid) {
let glyphStrings = this.morxProcessor.generateInputs(gid);
let result = new Set;
for (let glyphs of glyphStrings)this._addStrings(glyphs, 0, result, '');
return result;
}
_addStrings(glyphs, index, strings, string) {
let codePoints = this.font._cmapProcessor.codePointsForGlyph(glyphs[index]);
for (let codePoint of codePoints){
let s = string + String.fromCodePoint(codePoint);
if (index < glyphs.length - 1) this._addStrings(glyphs, index + 1, strings, s);
else strings.add(s);
}
}
constructor(font){
this.font = font;
this.morxProcessor = new (0, $99be642f82069918$export$2e2bcd8739ae039)(font);
this.fallbackPosition = false;
}
}
class $d7e93cca3cf8ce8a$export$2e2bcd8739ae039 {
/**
* Adds the given features to the last stage.
* Ignores features that have already been applied.
*/ _addFeatures(features, global) {
let stageIndex = this.stages.length - 1;
let stage = this.stages[stageIndex];
for (let feature of features)if (this.allFeatures[feature] == null) {
stage.push(feature);
this.allFeatures[feature] = stageIndex;
if (global) this.globalFeatures[feature] = true;
}
}
/**
* Add features to the last stage
*/ add(arg, global = true) {
if (this.stages.length === 0) this.stages.push([]);
if (typeof arg === 'string') arg = [
arg
];
if (Array.isArray(arg)) this._addFeatures(arg, global);
else if (typeof arg === 'object') {
this._addFeatures(arg.global || [], true);
this._addFeatures(arg.local || [], false);
} else throw new Error("Unsupported argument to ShapingPlan#add");
}
/**
* Add a new stage
*/ addStage(arg, global) {
if (typeof arg === 'function') this.stages.push(arg, []);
else {
this.stages.push([]);
this.add(arg, global);
}
}
setFeatureOverrides(features) {
if (Array.isArray(features)) this.add(features);
else if (typeof features === 'object') for(let tag in features){
if (features[tag]) this.add(tag);
else if (this.allFeatures[tag] != null) {
let stage = this.stages[this.allFeatures[tag]];
stage.splice(stage.indexOf(tag), 1);
delete this.allFeatures[tag];
delete this.globalFeatures[tag];
}
}
}
/**
* Assigns the global features to the given glyphs
*/ assignGlobalFeatures(glyphs) {
for (let glyph of glyphs)for(let feature in this.globalFeatures)glyph.features[feature] = true;
}
/**
* Executes the planned stages using the given OTProcessor
*/ process(processor, glyphs, positions) {
for (let stage of this.stages){
if (typeof stage === 'function') {
if (!positions) stage(this.font, glyphs, this);
} else if (stage.length > 0) processor.applyFeatures(stage, glyphs, positions);
}
}
constructor(font, script, direction){
this.font = font;
this.script = script;
this.direction = direction;
this.stages = [];
this.globalFeatures = {};
this.allFeatures = {};
}
}
const $d28fb665ee343afc$var$VARIATION_FEATURES = [
'rvrn'
];
const $d28fb665ee343afc$var$COMMON_FEATURES = [
'ccmp',
'locl',
'rlig',
'mark',
'mkmk'
];
const $d28fb665ee343afc$var$FRACTIONAL_FEATURES = [
'frac',
'numr',
'dnom'
];
const $d28fb665ee343afc$var$HORIZONTAL_FEATURES = [
'calt',
'clig',
'liga',
'rclt',
'curs',
'kern'
];
const $d28fb665ee343afc$var$VERTICAL_FEATURES = [
'vert'
];
const $d28fb665ee343afc$var$DIRECTIONAL_FEATURES = {
ltr: [
'ltra',
'ltrm'
],
rtl: [
'rtla',
'rtlm'
]
};
class $d28fb665ee343afc$export$2e2bcd8739ae039 {
static plan(plan, glyphs, features) {
// Plan the features we want to apply
this.planPreprocessing(plan);
this.planFeatures(plan);
this.planPostprocessing(plan, features);
// Assign the global features to all the glyphs
plan.assignGlobalFeatures(glyphs);
// Assign local features to glyphs
this.assignFeatures(plan, glyphs);
}
static planPreprocessing(plan) {
plan.add({
global: [
...$d28fb665ee343afc$var$VARIATION_FEATURES,
...$d28fb665ee343afc$var$DIRECTIONAL_FEATURES[plan.direction]
],
local: $d28fb665ee343afc$var$FRACTIONAL_FEATURES
});
}
static planFeatures(plan) {
// Do nothing by default. Let subclasses override this.
}
static planPostprocessing(plan, userFeatures) {
plan.add([
...$d28fb665ee343afc$var$COMMON_FEATURES,
...$d28fb665ee343afc$var$HORIZONTAL_FEATURES
]);
plan.setFeatureOverrides(userFeatures);
}
static assignFeatures(plan, glyphs) {
// Enable contextual fractions
for(let i = 0; i < glyphs.length; i++){
let glyph = glyphs[i];
if (glyph.codePoints[0] === 0x2044) {
let start = i;
let end = i + 1;
// Apply numerator
while(start > 0 && (0, $gfJaN$unicodeproperties.isDigit)(glyphs[start - 1].codePoints[0])){
glyphs[start - 1].features.numr = true;
glyphs[start - 1].features.frac = true;
start--;
}
// Apply denominator
while(end < glyphs.length && (0, $gfJaN$unicodeproperties.isDigit)(glyphs[end].codePoints[0])){
glyphs[end].features.dnom = true;
glyphs[end].features.frac = true;
end++;
}
// Apply fraction slash
glyph.features.frac = true;
i = end - 1;
}
}
}
}
(0, $gfJaN$swchelperscjs_define_propertycjs._)($d28fb665ee343afc$export$2e2bcd8739ae039, "zeroMarkWidths", 'AFTER_GPOS');
const $17ba6019f27bfcf9$var$trie = new (0, ($parcel$interopDefault($gfJaN$unicodetrie)))((0, $66a5b9fb5318558a$export$94fdf11bafc8de6b)("APABAAAAAAAAOAAAAf0BAv7tmi1MxDAUx7vtvjhAgcDgkEgEAnmXEBIMCYaEcygEiqBQ4FAkCE4ikUgMiiBJSAgSiUQSDMn9L9eSl6bddddug9t7yS/trevre+3r27pcNxZiG+yCfdCVv/9LeQxOwRm4AJegD27ALbgD9+ABPJF+z+BN/h7yDj5k/VOWX6SdmU5+wLWknggxDxaS8u0qiiX4uiz9XamQ3wzDMAzDMAzDMAzDVI/h959V/v7BMAzDMAzDMLlyNTNiMSdewVxbiA44B4/guz1qW58VYlMI0WsJ0W+N6kXw0spvPtdwhtkwnGM6uLaV4Xyzg3v3PM9DPfQ/sOg4xPWjipy31P8LTqbU304c/cLCUmWJLNB2Uz2U1KTeRKNmKHVMfbJC+/0loTZRH/W5cvEvBJPMbREkWt3FD1NcqXZBSpuE2Ad0PBehPtNrPtIEdYP+hiRt/V1jIiE69X4NT/uVZI3PUHE9bm5M7ePGdZWy951v7Nn6j8v1WWKP3mt6ttnsigx6VN7Vc0VomSSGqW2mGNP1muZPl7LfjNUaKNFtDGVf2fvE9O7VlBS5j333c5p/eeoOqcs1R/hIqDWLJ7TTlksirVT1SI7l8k4Yp+g3jafGcrU1RM6l9th80XOpnlN97bDNY4i4s61B0Si/ipa0uHMl6zqEjlFfCZm/TM8KmzQDjmuTAQ=="));
const $17ba6019f27bfcf9$var$FEATURES = [
'isol',
'fina',
'fin2',
'fin3',
'medi',
'med2',
'init'
];
const $17ba6019f27bfcf9$var$ShapingClasses = {
Non_Joining: 0,
Left_Joining: 1,
Right_Joining: 2,
Dual_Joining: 3,
Join_Causing: 3,
ALAPH: 4,
'DALATH RISH': 5,
Transparent: 6
};
const $17ba6019f27bfcf9$var$ISOL = 'isol';
const $17ba6019f27bfcf9$var$FINA = 'fina';
const $17ba6019f27bfcf9$var$FIN2 = 'fin2';
const $17ba6019f27bfcf9$var$FIN3 = 'fin3';
const $17ba6019f27bfcf9$var$MEDI = 'medi';
const $17ba6019f27bfcf9$var$MED2 = 'med2';
const $17ba6019f27bfcf9$var$INIT = 'init';
const $17ba6019f27bfcf9$var$NONE = null;
// Each entry is [prevAction, curAction, nextState]
const $17ba6019f27bfcf9$var$STATE_TABLE = [
// Non_Joining, Left_Joining, Right_Joining, Dual_Joining, ALAPH, DALATH RISH
// State 0: prev was U, not willing to join.
[
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$NONE,
0
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
1
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
1
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
6
]
],
// State 1: prev was R or ISOL/ALAPH, not willing to join.
[
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$NONE,
0
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
1
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$FIN2,
5
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
6
]
],
// State 2: prev was D/L in ISOL form, willing to join.
[
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$NONE,
0
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$INIT,
$17ba6019f27bfcf9$var$FINA,
1
],
[
$17ba6019f27bfcf9$var$INIT,
$17ba6019f27bfcf9$var$FINA,
3
],
[
$17ba6019f27bfcf9$var$INIT,
$17ba6019f27bfcf9$var$FINA,
4
],
[
$17ba6019f27bfcf9$var$INIT,
$17ba6019f27bfcf9$var$FINA,
6
]
],
// State 3: prev was D in FINA form, willing to join.
[
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$NONE,
0
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$MEDI,
$17ba6019f27bfcf9$var$FINA,
1
],
[
$17ba6019f27bfcf9$var$MEDI,
$17ba6019f27bfcf9$var$FINA,
3
],
[
$17ba6019f27bfcf9$var$MEDI,
$17ba6019f27bfcf9$var$FINA,
4
],
[
$17ba6019f27bfcf9$var$MEDI,
$17ba6019f27bfcf9$var$FINA,
6
]
],
// State 4: prev was FINA ALAPH, not willing to join.
[
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$NONE,
0
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$MED2,
$17ba6019f27bfcf9$var$ISOL,
1
],
[
$17ba6019f27bfcf9$var$MED2,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$MED2,
$17ba6019f27bfcf9$var$FIN2,
5
],
[
$17ba6019f27bfcf9$var$MED2,
$17ba6019f27bfcf9$var$ISOL,
6
]
],
// State 5: prev was FIN2/FIN3 ALAPH, not willing to join.
[
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$NONE,
0
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$ISOL,
$17ba6019f27bfcf9$var$ISOL,
1
],
[
$17ba6019f27bfcf9$var$ISOL,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$ISOL,
$17ba6019f27bfcf9$var$FIN2,
5
],
[
$17ba6019f27bfcf9$var$ISOL,
$17ba6019f27bfcf9$var$ISOL,
6
]
],
// State 6: prev was DALATH/RISH, not willing to join.
[
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$NONE,
0
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
1
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
2
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$FIN3,
5
],
[
$17ba6019f27bfcf9$var$NONE,
$17ba6019f27bfcf9$var$ISOL,
6
]
]
];
class $17ba6019f27bfcf9$export$2e2bcd8739ae039 extends (0, $d28fb665ee343afc$export$2e2bcd8739ae039) {
static planFeatures(plan) {
plan.add([
'ccmp',
'locl'
]);
for(let i = 0; i < $17ba6019f27bfcf9$var$FEATURES.length; i++){
let feature = $17ba6019f27bfcf9$var$FEATURES[i];
plan.addStage(feature, false);
}
plan.addStage('mset');
}
static assignFeatures(plan, glyphs) {
super.assignFeatures(plan, glyphs);
let prev = -1;
let state = 0;
let actions = [];
// Apply the state machine to map glyphs to features
for(let i = 0; i < glyphs.length; i++){
let curAction, prevAction;
var glyph = glyphs[i];
let type = $17ba6019f27bfcf9$var$getShapingClass(glyph.codePoints[0]);
if (type === $17ba6019f27bfcf9$var$ShapingClasses.Transparent) {
actions[i] = $17ba6019f27bfcf9$var$NONE;
continue;
}
[prevAction, curAction, state] = $17ba6019f27bfcf9$var$STATE_TABLE[state][type];
if (prevAction !== $17ba6019f27bfcf9$var$NONE && prev !== -1) actions[prev] = prevAction;
actions[i] = curAction;
prev = i;
}
// Apply the chosen features to their respective glyphs
for(let index = 0; index < glyphs.length; index++){
let feature;
var glyph = glyphs[index];
if (feature = actions[index]) glyph.features[feature] = true;
}
}
}
function $17ba6019f27bfcf9$var$getShapingClass(codePoint) {
let res = $17ba6019f27bfcf9$var$trie.get(codePoint);
if (res) return res - 1;
let category = (0, $gfJaN$unicodeproperties.getCategory)(codePoint);
if (category === 'Mn' || category === 'Me' || category === 'Cf') return $17ba6019f27bfcf9$var$ShapingClasses.Transparent;
return $17ba6019f27bfcf9$var$ShapingClasses.Non_Joining;
}
class $d6368085223f631e$export$2e2bcd8739ae039 {
reset(options = {}, index = 0) {
this.options = options;
this.flags = options.flags || {};
this.markAttachmentType = options.markAttachmentType || 0;
this.index = index;
}
get cur() {
return this.glyphs[this.index] || null;
}
shouldIgnore(glyph) {
return this.flags.ignoreMarks && glyph.isMark || this.flags.ignoreBaseGlyphs && glyph.isBase || this.flags.ignoreLigatures && glyph.isLigature || this.markAttachmentType && glyph.isMark && glyph.markAttachmentType !== this.markAttachmentType;
}
move(dir) {
this.index += dir;
while(0 <= this.index && this.index < this.glyphs.length && this.shouldIgnore(this.glyphs[this.index]))this.index += dir;
if (0 > this.index || this.index >= this.glyphs.length) return null;
return this.glyphs[this.index];
}
next() {
return this.move(1);
}
prev() {
return this.move(-1);
}
peek(count = 1) {
let idx = this.index;
let res = this.increment(count);
this.index = idx;
return res;
}
peekIndex(count = 1) {
let idx = this.index;
this.increment(count);
let res = this.index;
this.index = idx;
return res;
}
increment(count = 1) {
let dir = count < 0 ? -1 : 1;
count = Math.abs(count);
while(count--)this.move(dir);
return this.glyphs[this.index];
}
constructor(glyphs, options){
this.glyphs = glyphs;
this.reset(options);
}
}
const $7b226e6bbeadedeb$var$DEFAULT_SCRIPTS = [
'DFLT',
'dflt',
'latn'
];
class $7b226e6bbeadedeb$export$2e2bcd8739ae039 {
findScript(script) {
if (this.table.scriptList == null) return null;
if (!Array.isArray(script)) script = [
script
];
for (let s of script)for (let entry of this.table.scriptList){
if (entry.tag === s) return entry;
}
return null;
}
selectScript(script, language, direction) {
let changed = false;
let entry;
if (!this.script || script !== this.scriptTag) {
entry = this.findScript(script);
if (!entry) entry = this.findScript($7b226e6bbeadedeb$var$DEFAULT_SCRIPTS);
if (!entry) return this.scriptTag;
this.scriptTag = entry.tag;
this.script = entry.script;
this.language = null;
this.languageTag = null;
changed = true;
}
if (!direction || direction !== this.direction) this.direction = direction || $e38a1a895f6aeb54$export$9fddb9d0dd7d8a54(script);
if (language && language.length < 4) language += ' '.repeat(4 - language.length);
if (!language || language !== this.languageTag) {
this.language = null;
for (let lang of this.script.langSysRecords)if (lang.tag === language) {
this.language = lang.langSys;
this.languageTag = lang.tag;
break;
}
if (!this.language) {
this.language = this.script.defaultLangSys;
this.languageTag = null;
}
changed = true;
}
// Build a feature lookup table
if (changed) {
this.features = {};
if (this.language) for (let featureIndex of this.language.featureIndexes){
let record = this.table.featureList[featureIndex];
let substituteFeature = this.substituteFeatureForVariations(featureIndex);
this.features[record.tag] = substituteFeature || record.feature;
}
}
return this.scriptTag;
}
lookupsForFeatures(userFeatures = [], exclude) {
let lookups = [];
for (let tag of userFeatures){
let feature = this.features[tag];
if (!feature) continue;
for (let lookupIndex of feature.lookupListIndexes){
if (exclude && exclude.indexOf(lookupIndex) !== -1) continue;
lookups.push({
feature: tag,
index: lookupIndex,
lookup: this.table.lookupList.get(lookupIndex)
});
}
}
lookups.sort((a, b)=>a.index - b.index);
return lookups;
}
substituteFeatureForVariations(featureIndex) {
if (this.variationsIndex === -1) return null;
let record = this.table.featureVariations.featureVariationRecords[this.variationsIndex];
let substitutions = record.featureTableSubstitution.substitutions;
for (let substitution of substitutions){
if (substitution.featureIndex === featureIndex) return substitution.alternateFeatureTable;
}
return null;
}
findVariationsIndex(coords) {
let variations = this.table.featureVariations;
if (!variations) return -1;
let records = variations.featureVariationRecords;
for(let i = 0; i < records.length; i++){
let conditions = records[i].conditionSet.conditionTable;
if (this.variationConditionsMatch(conditions, coords)) return i;
}
return -1;
}
variationConditionsMatch(conditions, coords) {
return conditions.every((condition)=>{
let coord = condition.axisIndex < coords.length ? coords[condition.axisIndex] : 0;
return condition.filterRangeMinValue <= coord && coord <= condition.filterRangeMaxValue;
});
}
applyFeatures(userFeatures, glyphs, advances) {
let lookups = this.lookupsForFeatures(userFeatures);
this.applyLookups(lookups, glyphs, advances);
}
applyLookups(lookups, glyphs, positions) {
this.glyphs = glyphs;
this.positions = positions;
this.glyphIterator = new (0, $d6368085223f631e$export$2e2bcd8739ae039)(glyphs);
for (let { feature: feature, lookup: lookup } of lookups){
this.currentFeature = feature;
this.glyphIterator.reset(lookup.flags);
while(this.glyphIterator.index < glyphs.length){
if (!(feature in this.glyphIterator.cur.features)) {
this.glyphIterator.next();
continue;
}
for (let table of lookup.subTables){
let res = this.applyLookup(lookup.lookupType, table);
if (res) break;
}
this.glyphIterator.next();
}
}
}
applyLookup(lookup, table) {
throw new Error("applyLookup must be implemented by subclasses");
}
applyLookupList(lookupRecords) {
let options = this.glyphIterator.options;
let glyphIndex = this.glyphIterator.index;
for (let lookupRecord of lookupRecords){
// Reset flags and find glyph index for this lookup record
this.glyphIterator.reset(options, glyphIndex);
this.glyphIterator.increment(lookupRecord.sequenceIndex);
// Get the lookup and setup flags for subtables
let lookup = this.table.lookupList.get(lookupRecord.lookupListIndex);
this.glyphIterator.reset(lookup.flags, this.glyphIterator.index);
// Apply lookup subtables until one matches
for (let table of lookup.subTables){
if (this.applyLookup(lookup.lookupType, table)) break;
}
}
this.glyphIterator.reset(options, glyphIndex);
return true;
}
coverageIndex(coverage, glyph) {
if (glyph == null) glyph = this.glyphIterator.cur.id;
switch(coverage.version){
case 1:
return coverage.glyphs.indexOf(glyph);
case 2:
for (let range of coverage.rangeRecords){
if (range.start <= glyph && glyph <= range.end) return range.startCoverageIndex + glyph - range.start;
}
break;
}
return -1;
}
match(sequenceIndex, sequence, fn, matched) {
let pos = this.glyphIterator.index;
let glyph = this.glyphIterator.increment(sequenceIndex);
let idx = 0;
while(idx < sequence.length && glyph && fn(sequence[idx], glyph)){
if (matched) matched.push(this.glyphIterator.index);
idx++;
glyph = this.glyphIterator.next();
}
this.glyphIterator.index = pos;
if (idx < sequence.length) return false;
return matched || true;
}
sequenceMatches(sequenceIndex, sequence) {
return this.match(sequenceIndex, sequence, (component, glyph)=>component === glyph.id);
}
sequenceMatchIndices(sequenceIndex, sequence) {
return this.match(sequenceIndex, sequence, (component, glyph)=>{
// If the current feature doesn't apply to this glyph,
if (!(this.currentFeature in glyph.features)) return false;
return component === glyph.id;
}, []);
}
coverageSequenceMatches(sequenceIndex, sequence) {
return this.match(sequenceIndex, sequence, (coverage, glyph)=>this.coverageIndex(coverage, glyph.id) >= 0);
}
getClassID(glyph, classDef) {
switch(classDef.version){
case 1:
let i = glyph - classDef.startGlyph;
if (i >= 0 && i < classDef.classValueArray.length) return classDef.classValueArray[i];
break;
case 2:
for (let range of classDef.classRangeRecord){
if (range.start <= glyph && glyph <= range.end) return range.class;
}
break;
}
return 0;
}
classSequenceMatches(sequenceIndex, sequence, classDef) {
return this.match(sequenceIndex, sequence, (classID, glyph)=>classID === this.getClassID(glyph.id, classDef));
}
applyContext(table) {
let index, set;
switch(table.version){
case 1:
index = this.coverageIndex(table.coverage);
if (index === -1) return false;
set = table.ruleSets[index];
for (let rule of set){
if (this.sequenceMatches(1, rule.input)) return this.applyLookupList(rule.lookupRecords);
}
break;
case 2:
if (this.coverageIndex(table.coverage) === -1) return false;
index = this.getClassID(this.glyphIterator.cur.id, table.classDef);
if (index === -1) return false;
set = table.classSet[index];
for (let rule of set){
if (this.classSequenceMatches(1, rule.classes, table.classDef)) return this.applyLookupList(rule.lookupRecords);
}
break;
case 3:
if (this.coverageSequenceMatches(0, table.coverages)) return this.applyLookupList(table.lookupRecords);
break;
}
return false;
}
applyChainingContext(table) {
let index;
switch(table.version){
case 1:
index = this.coverageIndex(table.coverage);
if (index === -1) return false;
let set = table.chainRuleSets[index];
for (let rule of set){
if (this.sequenceMatches(-rule.backtrack.length, rule.backtrack) && this.sequenceMatches(1, rule.input) && this.sequenceMatches(1 + rule.input.length, rule.lookahead)) return this.applyLookupList(rule.lookupRecords);
}
break;
case 2:
if (this.coverageIndex(table.coverage) === -1) return false;
index = this.getClassID(this.glyphIterator.cur.id, table.inputClassDef);
let rules = table.chainClassSet[index];
if (!rules) return false;
for (let rule of rules){
if (this.classSequenceMatches(-rule.backtrack.length, rule.backtrack, table.backtrackClassDef) && this.classSequenceMatches(1, rule.input, table.inputClassDef) && this.classSequenceMatches(1 + rule.input.length, rule.lookahead, table.lookaheadClassDef)) return this.applyLookupList(rule.lookupRecords);
}
break;
case 3:
if (this.coverageSequenceMatches(-table.backtrackGlyphCount, table.backtrackCoverage) && this.coverageSequenceMatches(0, table.inputCoverage) && this.coverageSequenceMatches(table.inputGlyphCount, table.lookaheadCoverage)) return this.applyLookupList(table.lookupRecords);
break;
}
return false;
}
constructor(font, table){
this.font = font;
this.table = table;
this.script = null;
this.scriptTag = null;
this.language = null;
this.languageTag = null;
this.features = {};
this.lookups = {};
// Setup variation substitutions
this.variationsIndex = font._variationProcessor ? this.findVariationsIndex(font._variationProcessor.normalizedCoords) : -1;
// initialize to default script + language
this.selectScript();
// current context (set by applyFeatures)
this.glyphs = [];
this.positions = []; // only used by GPOS
this.ligatureID = 1;
this.currentFeature = null;
}
}
class $f22bb23c9fd478d8$export$2e2bcd8739ae039 {
get id() {
return this._id;
}
set id(id) {
this._id = id;
this.substituted = true;
let GDEF = this._font.GDEF;
if (GDEF && GDEF.glyphClassDef) {
// TODO: clean this up
let classID = (0, $7b226e6bbeadedeb$export$2e2bcd8739ae039).prototype.getClassID(id, GDEF.glyphClassDef);
this.isBase = classID === 1;
this.isLigature = classID === 2;
this.isMark = classID === 3;
this.markAttachmentType = GDEF.markAttachClassDef ? (0, $7b226e6bbeadedeb$export$2e2bcd8739ae039).prototype.getClassID(id, GDEF.markAttachClassDef) : 0;
} else {
this.isMark = this.codePoints.length > 0 && this.codePoints.every((0, $gfJaN$unicodeproperties.isMark));
this.isBase = !this.isMark;
this.isLigature = this.codePoints.length > 1;
this.markAttachmentType = 0;
}
}
copy() {
return new $f22bb23c9fd478d8$export$2e2bcd8739ae039(this._font, this.id, this.codePoints, this.features);
}
constructor(font, id, codePoints = [], features){
this._font = font;
this.codePoints = codePoints;
this.id = id;
this.features = {};
if (Array.isArray(features)) for(let i = 0; i < features.length; i++){
let feature = features[i];
this.features[feature] = true;
}
else if (typeof features === 'object') Object.assign(this.features, features);
this.ligatureID = null;
this.ligatureComponent = null;
this.isLigated = false;
this.cursiveAttachment = null;
this.markAttachment = null;
this.shaperInfo = null;
this.substituted = false;
this.isMultiplied = false;
}
}
class $fa1d9fd80dd7279e$export$2e2bcd8739ae039 extends (0, $d28fb665ee343afc$export$2e2bcd8739ae039) {
static planFeatures(plan) {
plan.add([
'ljmo',
'vjmo',
'tjmo'
], false);
}
static assignFeatures(plan, glyphs) {
let state = 0;
let i = 0;
while(i < glyphs.length){
let action;
let glyph = glyphs[i];
let code = glyph.codePoints[0];
let type = $fa1d9fd80dd7279e$var$getType(code);
[action, state] = $fa1d9fd80dd7279e$var$STATE_TABLE[state][type];
switch(action){
case $fa1d9fd80dd7279e$var$DECOMPOSE:
// Decompose the composed syllable if it is not supported by the font.
if (!plan.font.hasGlyphForCodePoint(code)) i = $fa1d9fd80dd7279e$var$decompose(glyphs, i, plan.font);
break;
case $fa1d9fd80dd7279e$var$COMPOSE:
// Found a decomposed syllable. Try to compose if supported by the font.
i = $fa1d9fd80dd7279e$var$compose(glyphs, i, plan.font);
break;
case $fa1d9fd80dd7279e$var$TONE_MARK:
// Got a valid syllable, followed by a tone mark. Move the tone mark to the beginning of the syllable.
$fa1d9fd80dd7279e$var$reorderToneMark(glyphs, i, plan.font);
break;
case $fa1d9fd80dd7279e$var$INVALID:
// Tone mark has no valid syllable to attach to, so insert a dotted circle
i = $fa1d9fd80dd7279e$var$insertDottedCircle(glyphs, i, plan.font);
break;
}
i++;
}
}
}
(0, $gfJaN$swchelperscjs_define_propertycjs._)($fa1d9fd80dd7279e$export$2e2bcd8739ae039, "zeroMarkWidths", 'NONE');
const $fa1d9fd80dd7279e$var$HANGUL_BASE = 0xac00;
const $fa1d9fd80dd7279e$var$HANGUL_END = 0xd7a4;
const $fa1d9fd80dd7279e$var$HANGUL_COUNT = $fa1d9fd80dd7279e$var$HANGUL_END - $fa1d9fd80dd7279e$var$HANGUL_BASE + 1;
const $fa1d9fd80dd7279e$var$L_BASE = 0x1100; // lead
const $fa1d9fd80dd7279e$var$V_BASE = 0x1161; // vowel
const $fa1d9fd80dd7279e$var$T_BASE = 0x11a7; // trail
const $fa1d9fd80dd7279e$var$L_COUNT = 19;
const $fa1d9fd80dd7279e$var$V_COUNT = 21;
const $fa1d9fd80dd7279e$var$T_COUNT = 28;
const $fa1d9fd80dd7279e$var$L_END = $fa1d9fd80dd7279e$var$L_BASE + $fa1d9fd80dd7279e$var$L_COUNT - 1;
const $fa1d9fd80dd7279e$var$V_END = $fa1d9fd80dd7279e$var$V_BASE + $fa1d9fd80dd7279e$var$V_COUNT - 1;
const $fa1d9fd80dd7279e$var$T_END = $fa1d9fd80dd7279e$var$T_BASE + $fa1d9fd80dd7279e$var$T_COUNT - 1;
const $fa1d9fd80dd7279e$var$DOTTED_CIRCLE = 0x25cc;
const $fa1d9fd80dd7279e$var$isL = (code)=>0x1100 <= code && code <= 0x115f || 0xa960 <= code && code <= 0xa97c;
const $fa1d9fd80dd7279e$var$isV = (code)=>0x1160 <= code && code <= 0x11a7 || 0xd7b0 <= code && code <= 0xd7c6;
const $fa1d9fd80dd7279e$var$isT = (code)=>0x11a8 <= code && code <= 0x11ff || 0xd7cb <= code && code <= 0xd7fb;
const $fa1d9fd80dd7279e$var$isTone = (code)=>0x302e <= code && code <= 0x302f;
const $fa1d9fd80dd7279e$var$isLVT = (code)=>$fa1d9fd80dd7279e$var$HANGUL_BASE <= code && code <= $fa1d9fd80dd7279e$var$HANGUL_END;
const $fa1d9fd80dd7279e$var$isLV = (code)=>code - $fa1d9fd80dd7279e$var$HANGUL_BASE < $fa1d9fd80dd7279e$var$HANGUL_COUNT && (code - $fa1d9fd80dd7279e$var$HANGUL_BASE) % $fa1d9fd80dd7279e$var$T_COUNT === 0;
const $fa1d9fd80dd7279e$var$isCombiningL = (code)=>$fa1d9fd80dd7279e$var$L_BASE <= code && code <= $fa1d9fd80dd7279e$var$L_END;
const $fa1d9fd80dd7279e$var$isCombiningV = (code)=>$fa1d9fd80dd7279e$var$V_BASE <= code && code <= $fa1d9fd80dd7279e$var$V_END;
const $fa1d9fd80dd7279e$var$isCombiningT = (code)=>$fa1d9fd80dd7279e$var$T_BASE + 1 && 1 <= code && code <= $fa1d9fd80dd7279e$var$T_END;
// Character categories
const $fa1d9fd80dd7279e$var$X = 0; // Other character
const $fa1d9fd80dd7279e$var$L = 1; // Leading consonant
const $fa1d9fd80dd7279e$var$V = 2; // Medial vowel
const $fa1d9fd80dd7279e$var$T = 3; // Trailing consonant
const $fa1d9fd80dd7279e$var$LV = 4; // Composed <LV> syllable
const $fa1d9fd80dd7279e$var$LVT = 5; // Composed <LVT> syllable
const $fa1d9fd80dd7279e$var$M = 6; // Tone mark
// This function classifies a character using the above categories.
function $fa1d9fd80dd7279e$var$getType(code) {
if ($fa1d9fd80dd7279e$var$isL(code)) return $fa1d9fd80dd7279e$var$L;
if ($fa1d9fd80dd7279e$var$isV(code)) return $fa1d9fd80dd7279e$var$V;
if ($fa1d9fd80dd7279e$var$isT(code)) return $fa1d9fd80dd7279e$var$T;
if ($fa1d9fd80dd7279e$var$isLV(code)) return $fa1d9fd80dd7279e$var$LV;
if ($fa1d9fd80dd7279e$var$isLVT(code)) return $fa1d9fd80dd7279e$var$LVT;
if ($fa1d9fd80dd7279e$var$isTone(code)) return $fa1d9fd80dd7279e$var$M;
return $fa1d9fd80dd7279e$var$X;
}
// State machine actions
const $fa1d9fd80dd7279e$var$NO_ACTION = 0;
const $fa1d9fd80dd7279e$var$DECOMPOSE = 1;
const $fa1d9fd80dd7279e$var$COMPOSE = 2;
const $fa1d9fd80dd7279e$var$TONE_MARK = 4;
const $fa1d9fd80dd7279e$var$INVALID = 5;
// Build a state machine that accepts valid syllables, and applies actions along the way.
// The logic this is implementing is documented at the top of the file.
const $fa1d9fd80dd7279e$var$STATE_TABLE = [
// X L V T LV LVT M
// State 0: start state
[
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
1
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
2
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
3
],
[
$fa1d9fd80dd7279e$var$INVALID,
0
]
],
// State 1: <L>
[
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
1
],
[
$fa1d9fd80dd7279e$var$COMPOSE,
2
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
2
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
3
],
[
$fa1d9fd80dd7279e$var$INVALID,
0
]
],
// State 2: <L,V> or <LV>
[
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
1
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$COMPOSE,
3
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
2
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
3
],
[
$fa1d9fd80dd7279e$var$TONE_MARK,
0
]
],
// State 3: <L,V,T> or <LVT>
[
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
1
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$NO_ACTION,
0
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
2
],
[
$fa1d9fd80dd7279e$var$DECOMPOSE,
3
],
[
$fa1d9fd80dd7279e$var$TONE_MARK,
0
]
]
];
function $fa1d9fd80dd7279e$var$getGlyph(font, code, features) {
return new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(font, font.glyphForCodePoint(code).id, [
code
], features);
}
function $fa1d9fd80dd7279e$var$decompose(glyphs, i, font) {
let glyph = glyphs[i];
let code = glyph.codePoints[0];
let s = code - $fa1d9fd80dd7279e$var$HANGUL_BASE;
let t = $fa1d9fd80dd7279e$var$T_BASE + s % $fa1d9fd80dd7279e$var$T_COUNT;
s = s / $fa1d9fd80dd7279e$var$T_COUNT | 0;
let l = $fa1d9fd80dd7279e$var$L_BASE + s / $fa1d9fd80dd7279e$var$V_COUNT | 0;
let v = $fa1d9fd80dd7279e$var$V_BASE + s % $fa1d9fd80dd7279e$var$V_COUNT;
// Don't decompose if all of the components are not available
if (!font.hasGlyphForCodePoint(l) || !font.hasGlyphForCodePoint(v) || t !== $fa1d9fd80dd7279e$var$T_BASE && !font.hasGlyphForCodePoint(t)) return i;
// Replace the current glyph with decomposed L, V, and T glyphs,
// and apply the proper OpenType features to each component.
let ljmo = $fa1d9fd80dd7279e$var$getGlyph(font, l, glyph.features);
ljmo.features.ljmo = true;
let vjmo = $fa1d9fd80dd7279e$var$getGlyph(font, v, glyph.features);
vjmo.features.vjmo = true;
let insert = [
ljmo,
vjmo
];
if (t > $fa1d9fd80dd7279e$var$T_BASE) {
let tjmo = $fa1d9fd80dd7279e$var$getGlyph(font, t, glyph.features);
tjmo.features.tjmo = true;
insert.push(tjmo);
}
glyphs.splice(i, 1, ...insert);
return i + insert.length - 1;
}
function $fa1d9fd80dd7279e$var$compose(glyphs, i, font) {
let glyph = glyphs[i];
let code = glyphs[i].codePoints[0];
let type = $fa1d9fd80dd7279e$var$getType(code);
let prev = glyphs[i - 1].codePoints[0];
let prevType = $fa1d9fd80dd7279e$var$getType(prev);
// Figure out what type of syllable we're dealing with
let lv, ljmo, vjmo, tjmo;
if (prevType === $fa1d9fd80dd7279e$var$LV && type === $fa1d9fd80dd7279e$var$T) {
// <LV,T>
lv = prev;
tjmo = glyph;
} else {
if (type === $fa1d9fd80dd7279e$var$V) {
// <L,V>
ljmo = glyphs[i - 1];
vjmo = glyph;
} else {
// <L,V,T>
ljmo = glyphs[i - 2];
vjmo = glyphs[i - 1];
tjmo = glyph;
}
let l = ljmo.codePoints[0];
let v = vjmo.codePoints[0];
// Make sure L and V are combining characters
if ($fa1d9fd80dd7279e$var$isCombiningL(l) && $fa1d9fd80dd7279e$var$isCombiningV(v)) lv = $fa1d9fd80dd7279e$var$HANGUL_BASE + ((l - $fa1d9fd80dd7279e$var$L_BASE) * $fa1d9fd80dd7279e$var$V_COUNT + (v - $fa1d9fd80dd7279e$var$V_BASE)) * $fa1d9fd80dd7279e$var$T_COUNT;
}
let t = tjmo && tjmo.codePoints[0] || $fa1d9fd80dd7279e$var$T_BASE;
if (lv != null && (t === $fa1d9fd80dd7279e$var$T_BASE || $fa1d9fd80dd7279e$var$isCombiningT(t))) {
let s = lv + (t - $fa1d9fd80dd7279e$var$T_BASE);
// Replace with a composed glyph if supported by the font,
// otherwise apply the proper OpenType features to each component.
if (font.hasGlyphForCodePoint(s)) {
let del = prevType === $fa1d9fd80dd7279e$var$V ? 3 : 2;
glyphs.splice(i - del + 1, del, $fa1d9fd80dd7279e$var$getGlyph(font, s, glyph.features));
return i - del + 1;
}
}
// Didn't compose (either a non-combining component or unsupported by font).
if (ljmo) ljmo.features.ljmo = true;
if (vjmo) vjmo.features.vjmo = true;
if (tjmo) tjmo.features.tjmo = true;
if (prevType === $fa1d9fd80dd7279e$var$LV) {
// Sequence was originally <L,V>, which got combined earlier.
// Either the T was non-combining, or the LVT glyph wasn't supported.
// Decompose the glyph again and apply OT features.
$fa1d9fd80dd7279e$var$decompose(glyphs, i - 1, font);
return i + 1;
}
return i;
}
function $fa1d9fd80dd7279e$var$getLength(code) {
switch($fa1d9fd80dd7279e$var$getType(code)){
case $fa1d9fd80dd7279e$var$LV:
case $fa1d9fd80dd7279e$var$LVT:
return 1;
case $fa1d9fd80dd7279e$var$V:
return 2;
case $fa1d9fd80dd7279e$var$T:
return 3;
}
}
function $fa1d9fd80dd7279e$var$reorderToneMark(glyphs, i, font) {
let glyph = glyphs[i];
let code = glyphs[i].codePoints[0];
// Move tone mark to the beginning of the previous syllable, unless it is zero width
if (font.glyphForCodePoint(code).advanceWidth === 0) return;
let prev = glyphs[i - 1].codePoints[0];
let len = $fa1d9fd80dd7279e$var$getLength(prev);
glyphs.splice(i, 1);
return glyphs.splice(i - len, 0, glyph);
}
function $fa1d9fd80dd7279e$var$insertDottedCircle(glyphs, i, font) {
let glyph = glyphs[i];
let code = glyphs[i].codePoints[0];
if (font.hasGlyphForCodePoint($fa1d9fd80dd7279e$var$DOTTED_CIRCLE)) {
let dottedCircle = $fa1d9fd80dd7279e$var$getGlyph(font, $fa1d9fd80dd7279e$var$DOTTED_CIRCLE, glyph.features);
// If the tone mark is zero width, insert the dotted circle before, otherwise after
let idx = font.glyphForCodePoint(code).advanceWidth === 0 ? i : i + 1;
glyphs.splice(idx, 0, dottedCircle);
i++;
}
return i;
}
var $d22b56f2cf15e5ba$exports = {};
$d22b56f2cf15e5ba$exports = JSON.parse("{\"stateTable\":[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,2,3,4,5,6,7,8,9,0,10,11,11,12,13,14,15,16,17],[0,0,0,18,19,20,21,22,23,0,24,0,0,25,26,0,0,27,0],[0,0,0,28,29,30,31,32,33,0,34,0,0,35,36,0,0,37,0],[0,0,0,38,5,7,7,8,9,0,10,0,0,0,13,0,0,16,0],[0,39,0,0,0,40,41,0,9,0,10,0,0,0,42,0,39,0,0],[0,0,0,0,43,44,44,8,9,0,0,0,0,12,43,0,0,0,0],[0,0,0,0,43,44,44,8,9,0,0,0,0,0,43,0,0,0,0],[0,0,0,45,46,47,48,49,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,50,0,0,51,0,10,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,52,0,0,0,0,0,0,0,0],[0,0,0,53,54,55,56,57,58,0,59,0,0,60,61,0,0,62,0],[0,0,0,4,5,7,7,8,9,0,10,0,0,0,13,0,0,16,0],[0,63,64,0,0,40,41,0,9,0,10,0,0,0,42,0,63,0,0],[0,2,3,4,5,6,7,8,9,0,10,11,11,12,13,0,2,16,0],[0,0,0,18,65,20,21,22,23,0,24,0,0,25,26,0,0,27,0],[0,0,0,0,66,67,67,8,9,0,10,0,0,0,68,0,0,0,0],[0,0,0,69,0,70,70,0,71,0,72,0,0,0,0,0,0,0,0],[0,0,0,73,19,74,74,22,23,0,24,0,0,0,26,0,0,27,0],[0,75,0,0,0,76,77,0,23,0,24,0,0,0,78,0,75,0,0],[0,0,0,0,79,80,80,22,23,0,0,0,0,25,79,0,0,0,0],[0,0,0,18,19,20,74,22,23,0,24,0,0,25,26,0,0,27,0],[0,0,0,81,82,83,84,85,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,86,0,0,87,0,24,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,88,0,0,0,0,0,0,0,0],[0,0,0,18,19,74,74,22,23,0,24,0,0,0,26,0,0,27,0],[0,89,90,0,0,76,77,0,23,0,24,0,0,0,78,0,89,0,0],[0,0,0,0,91,92,92,22,23,0,24,0,0,0,93,0,0,0,0],[0,0,0,94,29,95,31,32,33,0,34,0,0,0,36,0,0,37,0],[0,96,0,0,0,97,98,0,33,0,34,0,0,0,99,0,96,0,0],[0,0,0,0,100,101,101,32,33,0,0,0,0,35,100,0,0,0,0],[0,0,0,0,100,101,101,32,33,0,0,0,0,0,100,0,0,0,0],[0,0,0,102,103,104,105,106,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,107,0,0,108,0,34,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,109,0,0,0,0,0,0,0,0],[0,0,0,28,29,95,31,32,33,0,34,0,0,0,36,0,0,37,0],[0,110,111,0,0,97,98,0,33,0,34,0,0,0,99,0,110,0,0],[0,0,0,0,112,113,113,32,33,0,34,0,0,0,114,0,0,0,0],[0,0,0,0,5,7,7,8,9,0,10,0,0,0,13,0,0,16,0],[0,0,0,115,116,117,118,8,9,0,10,0,0,119,120,0,0,16,0],[0,0,0,0,0,121,121,0,9,0,10,0,0,0,42,0,0,0,0],[0,39,0,122,0,123,123,8,9,0,10,0,0,0,42,0,39,0,0],[0,124,64,0,0,0,0,0,0,0,0,0,0,0,0,0,124,0,0],[0,39,0,0,0,121,125,0,9,0,10,0,0,0,42,0,39,0,0],[0,0,0,0,0,126,126,8,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,46,47,48,49,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,47,47,49,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,127,127,49,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,128,127,127,49,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,129,130,131,132,133,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0],[0,0,0,0,0,50,0,0,0,0,10,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,134,0,0,0,0,0,0,0,0],[0,0,0,135,54,56,56,57,58,0,59,0,0,0,61,0,0,62,0],[0,136,0,0,0,137,138,0,58,0,59,0,0,0,139,0,136,0,0],[0,0,0,0,140,141,141,57,58,0,0,0,0,60,140,0,0,0,0],[0,0,0,0,140,141,141,57,58,0,0,0,0,0,140,0,0,0,0],[0,0,0,142,143,144,145,146,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,147,0,0,148,0,59,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,149,0,0,0,0,0,0,0,0],[0,0,0,53,54,56,56,57,58,0,59,0,0,0,61,0,0,62,0],[0,150,151,0,0,137,138,0,58,0,59,0,0,0,139,0,150,0,0],[0,0,0,0,152,153,153,57,58,0,59,0,0,0,154,0,0,0,0],[0,0,0,155,116,156,157,8,9,0,10,0,0,158,120,0,0,16,0],[0,0,0,0,0,121,121,0,9,0,10,0,0,0,0,0,0,0,0],[0,75,3,4,5,159,160,8,161,0,162,0,11,12,163,0,75,16,0],[0,0,0,0,0,40,164,0,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,165,44,44,8,9,0,0,0,0,0,165,0,0,0,0],[0,124,64,0,0,40,164,0,9,0,10,0,0,0,42,0,124,0,0],[0,0,0,0,0,70,70,0,71,0,72,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,71,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,166,0,0,167,0,72,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,168,0,0,0,0,0,0,0,0],[0,0,0,0,19,74,74,22,23,0,24,0,0,0,26,0,0,27,0],[0,0,0,0,79,80,80,22,23,0,0,0,0,0,79,0,0,0,0],[0,0,0,169,170,171,172,22,23,0,24,0,0,173,174,0,0,27,0],[0,0,0,0,0,175,175,0,23,0,24,0,0,0,78,0,0,0,0],[0,75,0,176,0,177,177,22,23,0,24,0,0,0,78,0,75,0,0],[0,178,90,0,0,0,0,0,0,0,0,0,0,0,0,0,178,0,0],[0,75,0,0,0,175,179,0,23,0,24,0,0,0,78,0,75,0,0],[0,0,0,0,0,180,180,22,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,82,83,84,85,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,83,83,85,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,181,181,85,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,182,181,181,85,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,183,184,185,186,187,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,0],[0,0,0,0,0,86,0,0,0,0,24,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,188,0,0,0,0,0,0,0,0],[0,0,0,189,170,190,191,22,23,0,24,0,0,192,174,0,0,27,0],[0,0,0,0,0,175,175,0,23,0,24,0,0,0,0,0,0,0,0],[0,0,0,0,0,76,193,0,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,194,80,80,22,23,0,0,0,0,0,194,0,0,0,0],[0,178,90,0,0,76,193,0,23,0,24,0,0,0,78,0,178,0,0],[0,0,0,0,29,95,31,32,33,0,34,0,0,0,36,0,0,37,0],[0,0,0,0,100,101,101,32,33,0,0,0,0,0,100,0,0,0,0],[0,0,0,195,196,197,198,32,33,0,34,0,0,199,200,0,0,37,0],[0,0,0,0,0,201,201,0,33,0,34,0,0,0,99,0,0,0,0],[0,96,0,202,0,203,203,32,33,0,34,0,0,0,99,0,96,0,0],[0,204,111,0,0,0,0,0,0,0,0,0,0,0,0,0,204,0,0],[0,96,0,0,0,201,205,0,33,0,34,0,0,0,99,0,96,0,0],[0,0,0,0,0,206,206,32,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,103,104,105,106,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,104,104,106,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,207,207,106,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,208,207,207,106,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,209,210,211,212,213,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,34,0,0,0,0,0,0,0,0],[0,0,0,0,0,107,0,0,0,0,34,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,214,0,0,0,0,0,0,0,0],[0,0,0,215,196,216,217,32,33,0,34,0,0,218,200,0,0,37,0],[0,0,0,0,0,201,201,0,33,0,34,0,0,0,0,0,0,0,0],[0,0,0,0,0,97,219,0,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,220,101,101,32,33,0,0,0,0,0,220,0,0,0,0],[0,204,111,0,0,97,219,0,33,0,34,0,0,0,99,0,204,0,0],[0,0,0,221,116,222,222,8,9,0,10,0,0,0,120,0,0,16,0],[0,223,0,0,0,40,224,0,9,0,10,0,0,0,42,0,223,0,0],[0,0,0,0,225,44,44,8,9,0,0,0,0,119,225,0,0,0,0],[0,0,0,115,116,117,222,8,9,0,10,0,0,119,120,0,0,16,0],[0,0,0,115,116,222,222,8,9,0,10,0,0,0,120,0,0,16,0],[0,226,64,0,0,40,224,0,9,0,10,0,0,0,42,0,226,0,0],[0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0],[0,39,0,0,0,121,121,0,9,0,10,0,0,0,42,0,39,0,0],[0,0,0,0,0,44,44,8,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,227,0,228,229,0,9,0,10,0,0,230,0,0,0,0,0],[0,39,0,122,0,121,121,0,9,0,10,0,0,0,42,0,39,0,0],[0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,231,231,49,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,232,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,130,131,132,133,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,131,131,133,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,233,233,133,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,234,233,233,133,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,235,236,237,238,239,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,54,56,56,57,58,0,59,0,0,0,61,0,0,62,0],[0,0,0,240,241,242,243,57,58,0,59,0,0,244,245,0,0,62,0],[0,0,0,0,0,246,246,0,58,0,59,0,0,0,139,0,0,0,0],[0,136,0,247,0,248,248,57,58,0,59,0,0,0,139,0,136,0,0],[0,249,151,0,0,0,0,0,0,0,0,0,0,0,0,0,249,0,0],[0,136,0,0,0,246,250,0,58,0,59,0,0,0,139,0,136,0,0],[0,0,0,0,0,251,251,57,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,143,144,145,146,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,144,144,146,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,252,252,146,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,253,252,252,146,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,254,255,256,257,258,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,59,0,0,0,0,0,0,0,0],[0,0,0,0,0,147,0,0,0,0,59,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,259,0,0,0,0,0,0,0,0],[0,0,0,260,241,261,262,57,58,0,59,0,0,263,245,0,0,62,0],[0,0,0,0,0,246,246,0,58,0,59,0,0,0,0,0,0,0,0],[0,0,0,0,0,137,264,0,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,265,141,141,57,58,0,0,0,0,0,265,0,0,0,0],[0,249,151,0,0,137,264,0,58,0,59,0,0,0,139,0,249,0,0],[0,0,0,221,116,222,222,8,9,0,10,0,0,0,120,0,0,16,0],[0,0,0,0,225,44,44,8,9,0,0,0,0,158,225,0,0,0,0],[0,0,0,155,116,156,222,8,9,0,10,0,0,158,120,0,0,16,0],[0,0,0,155,116,222,222,8,9,0,10,0,0,0,120,0,0,16,0],[0,0,0,0,43,266,266,8,161,0,24,0,0,12,267,0,0,0,0],[0,75,0,176,43,268,268,269,161,0,24,0,0,0,267,0,75,0,0],[0,0,0,0,0,270,0,0,271,0,162,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,272,0,0,0,0,0,0,0,0],[0,273,274,0,0,40,41,0,9,0,10,0,0,0,42,0,273,0,0],[0,0,0,40,0,123,123,8,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,121,275,0,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,72,0,0,0,0,0,0,0,0],[0,0,0,0,0,166,0,0,0,0,72,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,276,0,0,0,0,0,0,0,0],[0,0,0,277,170,278,278,22,23,0,24,0,0,0,174,0,0,27,0],[0,279,0,0,0,76,280,0,23,0,24,0,0,0,78,0,279,0,0],[0,0,0,0,281,80,80,22,23,0,0,0,0,173,281,0,0,0,0],[0,0,0,169,170,171,278,22,23,0,24,0,0,173,174,0,0,27,0],[0,0,0,169,170,278,278,22,23,0,24,0,0,0,174,0,0,27,0],[0,282,90,0,0,76,280,0,23,0,24,0,0,0,78,0,282,0,0],[0,0,0,0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0],[0,75,0,0,0,175,175,0,23,0,24,0,0,0,78,0,75,0,0],[0,0,0,0,0,80,80,22,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,283,0,284,285,0,23,0,24,0,0,286,0,0,0,0,0],[0,75,0,176,0,175,175,0,23,0,24,0,0,0,78,0,75,0,0],[0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,287,287,85,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,288,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,184,185,186,187,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,185,185,187,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,289,289,187,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,290,289,289,187,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,291,292,293,294,295,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,277,170,278,278,22,23,0,24,0,0,0,174,0,0,27,0],[0,0,0,0,281,80,80,22,23,0,0,0,0,192,281,0,0,0,0],[0,0,0,189,170,190,278,22,23,0,24,0,0,192,174,0,0,27,0],[0,0,0,189,170,278,278,22,23,0,24,0,0,0,174,0,0,27,0],[0,0,0,76,0,177,177,22,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,175,296,0,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,297,196,298,298,32,33,0,34,0,0,0,200,0,0,37,0],[0,299,0,0,0,97,300,0,33,0,34,0,0,0,99,0,299,0,0],[0,0,0,0,301,101,101,32,33,0,0,0,0,199,301,0,0,0,0],[0,0,0,195,196,197,298,32,33,0,34,0,0,199,200,0,0,37,0],[0,0,0,195,196,298,298,32,33,0,34,0,0,0,200,0,0,37,0],[0,302,111,0,0,97,300,0,33,0,34,0,0,0,99,0,302,0,0],[0,0,0,0,0,0,0,0,33,0,0,0,0,0,0,0,0,0,0],[0,96,0,0,0,201,201,0,33,0,34,0,0,0,99,0,96,0,0],[0,0,0,0,0,101,101,32,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,303,0,304,305,0,33,0,34,0,0,306,0,0,0,0,0],[0,96,0,202,0,201,201,0,33,0,34,0,0,0,99,0,96,0,0],[0,0,0,0,0,0,0,32,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,307,307,106,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,308,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,210,211,212,213,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,211,211,213,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,309,309,213,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,310,309,309,213,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,311,312,313,314,315,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,297,196,298,298,32,33,0,34,0,0,0,200,0,0,37,0],[0,0,0,0,301,101,101,32,33,0,0,0,0,218,301,0,0,0,0],[0,0,0,215,196,216,298,32,33,0,34,0,0,218,200,0,0,37,0],[0,0,0,215,196,298,298,32,33,0,34,0,0,0,200,0,0,37,0],[0,0,0,97,0,203,203,32,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,201,316,0,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,116,222,222,8,9,0,10,0,0,0,120,0,0,16,0],[0,0,0,0,225,44,44,8,9,0,0,0,0,0,225,0,0,0,0],[0,0,0,317,318,319,320,8,9,0,10,0,0,321,322,0,0,16,0],[0,223,0,323,0,123,123,8,9,0,10,0,0,0,42,0,223,0,0],[0,223,0,0,0,121,324,0,9,0,10,0,0,0,42,0,223,0,0],[0,0,0,325,318,326,327,8,9,0,10,0,0,328,322,0,0,16,0],[0,0,0,64,0,121,121,0,9,0,10,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,9,0,0,0,0,230,0,0,0,0,0],[0,0,0,227,0,228,121,0,9,0,10,0,0,230,0,0,0,0,0],[0,0,0,227,0,121,121,0,9,0,10,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,49,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,46,0,0],[0,0,0,0,0,329,329,133,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,330,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,236,237,238,239,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,237,237,239,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,331,331,239,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,332,331,331,239,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,333,40,121,334,0,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,335,241,336,336,57,58,0,59,0,0,0,245,0,0,62,0],[0,337,0,0,0,137,338,0,58,0,59,0,0,0,139,0,337,0,0],[0,0,0,0,339,141,141,57,58,0,0,0,0,244,339,0,0,0,0],[0,0,0,240,241,242,336,57,58,0,59,0,0,244,245,0,0,62,0],[0,0,0,240,241,336,336,57,58,0,59,0,0,0,245,0,0,62,0],[0,340,151,0,0,137,338,0,58,0,59,0,0,0,139,0,340,0,0],[0,0,0,0,0,0,0,0,58,0,0,0,0,0,0,0,0,0,0],[0,136,0,0,0,246,246,0,58,0,59,0,0,0,139,0,136,0,0],[0,0,0,0,0,141,141,57,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,341,0,342,343,0,58,0,59,0,0,344,0,0,0,0,0],[0,136,0,247,0,246,246,0,58,0,59,0,0,0,139,0,136,0,0],[0,0,0,0,0,0,0,57,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,345,345,146,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,346,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,255,256,257,258,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,256,256,258,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,347,347,258,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,348,347,347,258,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,349,350,351,352,353,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,335,241,336,336,57,58,0,59,0,0,0,245,0,0,62,0],[0,0,0,0,339,141,141,57,58,0,0,0,0,263,339,0,0,0,0],[0,0,0,260,241,261,336,57,58,0,59,0,0,263,245,0,0,62,0],[0,0,0,260,241,336,336,57,58,0,59,0,0,0,245,0,0,62,0],[0,0,0,137,0,248,248,57,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,246,354,0,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,126,126,8,23,0,0,0,0,0,0,0,0,0,0],[0,355,90,0,0,121,125,0,9,0,10,0,0,0,42,0,355,0,0],[0,0,0,0,0,356,356,269,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,357,358,359,360,361,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,162,0,0,0,0,0,0,0,0],[0,0,0,0,0,270,0,0,0,0,162,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,363,0,0,0,0,0,0,0,0],[0,0,0,364,116,365,366,8,161,0,162,0,0,367,120,0,0,16,0],[0,0,0,0,0,368,368,0,161,0,162,0,0,0,0,0,0,0,0],[0,0,0,40,0,121,121,0,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,170,278,278,22,23,0,24,0,0,0,174,0,0,27,0],[0,0,0,0,281,80,80,22,23,0,0,0,0,0,281,0,0,0,0],[0,0,0,369,370,371,372,22,23,0,24,0,0,373,374,0,0,27,0],[0,279,0,375,0,177,177,22,23,0,24,0,0,0,78,0,279,0,0],[0,279,0,0,0,175,376,0,23,0,24,0,0,0,78,0,279,0,0],[0,0,0,377,370,378,379,22,23,0,24,0,0,380,374,0,0,27,0],[0,0,0,90,0,175,175,0,23,0,24,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,23,0,0,0,0,286,0,0,0,0,0],[0,0,0,283,0,284,175,0,23,0,24,0,0,286,0,0,0,0,0],[0,0,0,283,0,175,175,0,23,0,24,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,85,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,82,0,0],[0,0,0,0,0,381,381,187,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,382,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,292,293,294,295,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,293,293,295,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,0,383,383,295,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,384,383,383,295,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,385,76,175,386,0,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,76,0,175,175,0,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,196,298,298,32,33,0,34,0,0,0,200,0,0,37,0],[0,0,0,0,301,101,101,32,33,0,0,0,0,0,301,0,0,0,0],[0,0,0,387,388,389,390,32,33,0,34,0,0,391,392,0,0,37,0],[0,299,0,393,0,203,203,32,33,0,34,0,0,0,99,0,299,0,0],[0,299,0,0,0,201,394,0,33,0,34,0,0,0,99,0,299,0,0],[0,0,0,395,388,396,397,32,33,0,34,0,0,398,392,0,0,37,0],[0,0,0,111,0,201,201,0,33,0,34,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,33,0,0,0,0,306,0,0,0,0,0],[0,0,0,303,0,304,201,0,33,0,34,0,0,306,0,0,0,0,0],[0,0,0,303,0,201,201,0,33,0,34,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,106,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,103,0,0],[0,0,0,0,0,399,399,213,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,400,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,312,313,314,315,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,313,313,315,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,0,401,401,315,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,402,401,401,315,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,403,97,201,404,0,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,97,0,201,201,0,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,405,318,406,406,8,9,0,10,0,0,0,322,0,0,16,0],[0,407,0,0,0,40,408,0,9,0,10,0,0,0,42,0,407,0,0],[0,0,0,0,409,44,44,8,9,0,0,0,0,321,409,0,0,0,0],[0,0,0,317,318,319,406,8,9,0,10,0,0,321,322,0,0,16,0],[0,0,0,317,318,406,406,8,9,0,10,0,0,0,322,0,0,16,0],[0,410,64,0,0,40,408,0,9,0,10,0,0,0,42,0,410,0,0],[0,223,0,0,0,121,121,0,9,0,10,0,0,0,42,0,223,0,0],[0,223,0,323,0,121,121,0,9,0,10,0,0,0,42,0,223,0,0],[0,0,0,405,318,406,406,8,9,0,10,0,0,0,322,0,0,16,0],[0,0,0,0,409,44,44,8,9,0,0,0,0,328,409,0,0,0,0],[0,0,0,325,318,326,406,8,9,0,10,0,0,328,322,0,0,16,0],[0,0,0,325,318,406,406,8,9,0,10,0,0,0,322,0,0,16,0],[0,0,0,0,0,0,0,133,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0],[0,0,0,0,0,411,411,239,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,412,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,40,121,334,0,9,0,10,0,0,0,42,0,0,0,0],[0,0,0,0,413,0,0,0,9,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,241,336,336,57,58,0,59,0,0,0,245,0,0,62,0],[0,0,0,0,339,141,141,57,58,0,0,0,0,0,339,0,0,0,0],[0,0,0,414,415,416,417,57,58,0,59,0,0,418,419,0,0,62,0],[0,337,0,420,0,248,248,57,58,0,59,0,0,0,139,0,337,0,0],[0,337,0,0,0,246,421,0,58,0,59,0,0,0,139,0,337,0,0],[0,0,0,422,415,423,424,57,58,0,59,0,0,425,419,0,0,62,0],[0,0,0,151,0,246,246,0,58,0,59,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,58,0,0,0,0,344,0,0,0,0,0],[0,0,0,341,0,342,246,0,58,0,59,0,0,344,0,0,0,0,0],[0,0,0,341,0,246,246,0,58,0,59,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,146,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,143,0,0],[0,0,0,0,0,426,426,258,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,427,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,350,351,352,353,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,351,351,353,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,0,428,428,353,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,429,428,428,353,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,430,137,246,431,0,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,137,0,246,246,0,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,432,116,433,434,8,161,0,162,0,0,435,120,0,0,16,0],[0,0,0,0,0,180,180,269,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,358,359,360,361,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,359,359,361,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,436,436,361,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,437,436,436,361,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,438,439,440,441,442,161,0,162,0,0,0,362,0,0,0,0],[0,443,274,0,0,0,0,0,0,0,0,0,0,0,0,0,443,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,444,116,445,445,8,161,0,162,0,0,0,120,0,0,16,0],[0,0,0,0,225,44,44,8,161,0,0,0,0,367,225,0,0,0,0],[0,0,0,364,116,365,445,8,161,0,162,0,0,367,120,0,0,16,0],[0,0,0,364,116,445,445,8,161,0,162,0,0,0,120,0,0,16,0],[0,0,0,0,0,0,0,0,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,446,370,447,447,22,23,0,24,0,0,0,374,0,0,27,0],[0,448,0,0,0,76,449,0,23,0,24,0,0,0,78,0,448,0,0],[0,0,0,0,450,80,80,22,23,0,0,0,0,373,450,0,0,0,0],[0,0,0,369,370,371,447,22,23,0,24,0,0,373,374,0,0,27,0],[0,0,0,369,370,447,447,22,23,0,24,0,0,0,374,0,0,27,0],[0,451,90,0,0,76,449,0,23,0,24,0,0,0,78,0,451,0,0],[0,279,0,0,0,175,175,0,23,0,24,0,0,0,78,0,279,0,0],[0,279,0,375,0,175,175,0,23,0,24,0,0,0,78,0,279,0,0],[0,0,0,446,370,447,447,22,23,0,24,0,0,0,374,0,0,27,0],[0,0,0,0,450,80,80,22,23,0,0,0,0,380,450,0,0,0,0],[0,0,0,377,370,378,447,22,23,0,24,0,0,380,374,0,0,27,0],[0,0,0,377,370,447,447,22,23,0,24,0,0,0,374,0,0,27,0],[0,0,0,0,0,0,0,187,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,184,0,0],[0,0,0,0,0,452,452,295,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,453,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,76,175,386,0,23,0,24,0,0,0,78,0,0,0,0],[0,0,0,0,454,0,0,0,23,0,0,0,0,0,0,0,0,0,0],[0,0,0,455,388,456,456,32,33,0,34,0,0,0,392,0,0,37,0],[0,457,0,0,0,97,458,0,33,0,34,0,0,0,99,0,457,0,0],[0,0,0,0,459,101,101,32,33,0,0,0,0,391,459,0,0,0,0],[0,0,0,387,388,389,456,32,33,0,34,0,0,391,392,0,0,37,0],[0,0,0,387,388,456,456,32,33,0,34,0,0,0,392,0,0,37,0],[0,460,111,0,0,97,458,0,33,0,34,0,0,0,99,0,460,0,0],[0,299,0,0,0,201,201,0,33,0,34,0,0,0,99,0,299,0,0],[0,299,0,393,0,201,201,0,33,0,34,0,0,0,99,0,299,0,0],[0,0,0,455,388,456,456,32,33,0,34,0,0,0,392,0,0,37,0],[0,0,0,0,459,101,101,32,33,0,0,0,0,398,459,0,0,0,0],[0,0,0,395,388,396,456,32,33,0,34,0,0,398,392,0,0,37,0],[0,0,0,395,388,456,456,32,33,0,34,0,0,0,392,0,0,37,0],[0,0,0,0,0,0,0,213,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,210,0,0],[0,0,0,0,0,461,461,315,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,462,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,97,201,404,0,33,0,34,0,0,0,99,0,0,0,0],[0,0,0,0,463,0,0,0,33,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,318,406,406,8,9,0,10,0,0,0,322,0,0,16,0],[0,0,0,0,409,44,44,8,9,0,0,0,0,0,409,0,0,0,0],[0,0,0,464,465,466,467,8,9,0,10,0,0,468,469,0,0,16,0],[0,407,0,470,0,123,123,8,9,0,10,0,0,0,42,0,407,0,0],[0,407,0,0,0,121,471,0,9,0,10,0,0,0,42,0,407,0,0],[0,0,0,472,465,473,474,8,9,0,10,0,0,475,469,0,0,16,0],[0,0,0,0,0,0,0,239,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,236,0,0],[0,0,0,0,0,0,476,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,477,415,478,478,57,58,0,59,0,0,0,419,0,0,62,0],[0,479,0,0,0,137,480,0,58,0,59,0,0,0,139,0,479,0,0],[0,0,0,0,481,141,141,57,58,0,0,0,0,418,481,0,0,0,0],[0,0,0,414,415,416,478,57,58,0,59,0,0,418,419,0,0,62,0],[0,0,0,414,415,478,478,57,58,0,59,0,0,0,419,0,0,62,0],[0,482,151,0,0,137,480,0,58,0,59,0,0,0,139,0,482,0,0],[0,337,0,0,0,246,246,0,58,0,59,0,0,0,139,0,337,0,0],[0,337,0,420,0,246,246,0,58,0,59,0,0,0,139,0,337,0,0],[0,0,0,477,415,478,478,57,58,0,59,0,0,0,419,0,0,62,0],[0,0,0,0,481,141,141,57,58,0,0,0,0,425,481,0,0,0,0],[0,0,0,422,415,423,478,57,58,0,59,0,0,425,419,0,0,62,0],[0,0,0,422,415,478,478,57,58,0,59,0,0,0,419,0,0,62,0],[0,0,0,0,0,0,0,258,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,0,0],[0,0,0,0,0,483,483,353,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,484,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,137,246,431,0,58,0,59,0,0,0,139,0,0,0,0],[0,0,0,0,485,0,0,0,58,0,0,0,0,0,0,0,0,0,0],[0,0,0,444,116,445,445,8,161,0,162,0,0,0,120,0,0,16,0],[0,0,0,0,225,44,44,8,161,0,0,0,0,435,225,0,0,0,0],[0,0,0,432,116,433,445,8,161,0,162,0,0,435,120,0,0,16,0],[0,0,0,432,116,445,445,8,161,0,162,0,0,0,120,0,0,16,0],[0,0,0,0,0,486,486,361,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,487,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,439,440,441,442,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,440,440,442,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,488,488,442,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,489,488,488,442,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,490,491,492,493,494,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,495,0,496,497,0,161,0,162,0,0,498,0,0,0,0,0],[0,0,0,0,116,445,445,8,161,0,162,0,0,0,120,0,0,16,0],[0,0,0,0,225,44,44,8,161,0,0,0,0,0,225,0,0,0,0],[0,0,0,0,370,447,447,22,23,0,24,0,0,0,374,0,0,27,0],[0,0,0,0,450,80,80,22,23,0,0,0,0,0,450,0,0,0,0],[0,0,0,499,500,501,502,22,23,0,24,0,0,503,504,0,0,27,0],[0,448,0,505,0,177,177,22,23,0,24,0,0,0,78,0,448,0,0],[0,448,0,0,0,175,506,0,23,0,24,0,0,0,78,0,448,0,0],[0,0,0,507,500,508,509,22,23,0,24,0,0,510,504,0,0,27,0],[0,0,0,0,0,0,0,295,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,292,0,0],[0,0,0,0,0,0,511,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,388,456,456,32,33,0,34,0,0,0,392,0,0,37,0],[0,0,0,0,459,101,101,32,33,0,0,0,0,0,459,0,0,0,0],[0,0,0,512,513,514,515,32,33,0,34,0,0,516,517,0,0,37,0],[0,457,0,518,0,203,203,32,33,0,34,0,0,0,99,0,457,0,0],[0,457,0,0,0,201,519,0,33,0,34,0,0,0,99,0,457,0,0],[0,0,0,520,513,521,522,32,33,0,34,0,0,523,517,0,0,37,0],[0,0,0,0,0,0,0,315,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,312,0,0],[0,0,0,0,0,0,524,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,525,465,526,526,8,9,0,10,0,0,0,469,0,0,16,0],[0,527,0,0,0,40,528,0,9,0,10,0,0,0,42,0,527,0,0],[0,0,0,0,529,44,44,8,9,0,0,0,0,468,529,0,0,0,0],[0,0,0,464,465,466,526,8,9,0,10,0,0,468,469,0,0,16,0],[0,0,0,464,465,526,526,8,9,0,10,0,0,0,469,0,0,16,0],[0,530,64,0,0,40,528,0,9,0,10,0,0,0,42,0,530,0,0],[0,407,0,0,0,121,121,0,9,0,10,0,0,0,42,0,407,0,0],[0,407,0,470,0,121,121,0,9,0,10,0,0,0,42,0,407,0,0],[0,0,0,525,465,526,526,8,9,0,10,0,0,0,469,0,0,16,0],[0,0,0,0,529,44,44,8,9,0,0,0,0,475,529,0,0,0,0],[0,0,0,472,465,473,526,8,9,0,10,0,0,475,469,0,0,16,0],[0,0,0,472,465,526,526,8,9,0,10,0,0,0,469,0,0,16,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,40,0,0],[0,0,0,0,415,478,478,57,58,0,59,0,0,0,419,0,0,62,0],[0,0,0,0,481,141,141,57,58,0,0,0,0,0,481,0,0,0,0],[0,0,0,531,532,533,534,57,58,0,59,0,0,535,536,0,0,62,0],[0,479,0,537,0,248,248,57,58,0,59,0,0,0,139,0,479,0,0],[0,479,0,0,0,246,538,0,58,0,59,0,0,0,139,0,479,0,0],[0,0,0,539,532,540,541,57,58,0,59,0,0,542,536,0,0,62,0],[0,0,0,0,0,0,0,353,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,350,0,0],[0,0,0,0,0,0,543,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,361,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,358,0,0],[0,0,0,0,0,544,544,442,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,545,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,491,492,493,494,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,492,492,494,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,546,546,494,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,547,546,546,494,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,548,549,368,550,0,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,274,0,368,368,0,161,0,162,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,161,0,0,0,0,498,0,0,0,0,0],[0,0,0,495,0,496,368,0,161,0,162,0,0,498,0,0,0,0,0],[0,0,0,495,0,368,368,0,161,0,162,0,0,0,0,0,0,0,0],[0,0,0,551,500,552,552,22,23,0,24,0,0,0,504,0,0,27,0],[0,553,0,0,0,76,554,0,23,0,24,0,0,0,78,0,553,0,0],[0,0,0,0,555,80,80,22,23,0,0,0,0,503,555,0,0,0,0],[0,0,0,499,500,501,552,22,23,0,24,0,0,503,504,0,0,27,0],[0,0,0,499,500,552,552,22,23,0,24,0,0,0,504,0,0,27,0],[0,556,90,0,0,76,554,0,23,0,24,0,0,0,78,0,556,0,0],[0,448,0,0,0,175,175,0,23,0,24,0,0,0,78,0,448,0,0],[0,448,0,505,0,175,175,0,23,0,24,0,0,0,78,0,448,0,0],[0,0,0,551,500,552,552,22,23,0,24,0,0,0,504,0,0,27,0],[0,0,0,0,555,80,80,22,23,0,0,0,0,510,555,0,0,0,0],[0,0,0,507,500,508,552,22,23,0,24,0,0,510,504,0,0,27,0],[0,0,0,507,500,552,552,22,23,0,24,0,0,0,504,0,0,27,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,76,0,0],[0,0,0,557,513,558,558,32,33,0,34,0,0,0,517,0,0,37,0],[0,559,0,0,0,97,560,0,33,0,34,0,0,0,99,0,559,0,0],[0,0,0,0,561,101,101,32,33,0,0,0,0,516,561,0,0,0,0],[0,0,0,512,513,514,558,32,33,0,34,0,0,516,517,0,0,37,0],[0,0,0,512,513,558,558,32,33,0,34,0,0,0,517,0,0,37,0],[0,562,111,0,0,97,560,0,33,0,34,0,0,0,99,0,562,0,0],[0,457,0,0,0,201,201,0,33,0,34,0,0,0,99,0,457,0,0],[0,457,0,518,0,201,201,0,33,0,34,0,0,0,99,0,457,0,0],[0,0,0,557,513,558,558,32,33,0,34,0,0,0,517,0,0,37,0],[0,0,0,0,561,101,101,32,33,0,0,0,0,523,561,0,0,0,0],[0,0,0,520,513,521,558,32,33,0,34,0,0,523,517,0,0,37,0],[0,0,0,520,513,558,558,32,33,0,34,0,0,0,517,0,0,37,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,97,0,0],[0,0,0,0,465,526,526,8,9,0,10,0,0,0,469,0,0,16,0],[0,0,0,0,529,44,44,8,9,0,0,0,0,0,529,0,0,0,0],[0,0,0,563,66,564,565,8,9,0,10,0,0,566,68,0,0,16,0],[0,527,0,567,0,123,123,8,9,0,10,0,0,0,42,0,527,0,0],[0,527,0,0,0,121,568,0,9,0,10,0,0,0,42,0,527,0,0],[0,0,0,569,66,570,571,8,9,0,10,0,0,572,68,0,0,16,0],[0,0,0,573,532,574,574,57,58,0,59,0,0,0,536,0,0,62,0],[0,575,0,0,0,137,576,0,58,0,59,0,0,0,139,0,575,0,0],[0,0,0,0,577,141,141,57,58,0,0,0,0,535,577,0,0,0,0],[0,0,0,531,532,533,574,57,58,0,59,0,0,535,536,0,0,62,0],[0,0,0,531,532,574,574,57,58,0,59,0,0,0,536,0,0,62,0],[0,578,151,0,0,137,576,0,58,0,59,0,0,0,139,0,578,0,0],[0,479,0,0,0,246,246,0,58,0,59,0,0,0,139,0,479,0,0],[0,479,0,537,0,246,246,0,58,0,59,0,0,0,139,0,479,0,0],[0,0,0,573,532,574,574,57,58,0,59,0,0,0,536,0,0,62,0],[0,0,0,0,577,141,141,57,58,0,0,0,0,542,577,0,0,0,0],[0,0,0,539,532,540,574,57,58,0,59,0,0,542,536,0,0,62,0],[0,0,0,539,532,574,574,57,58,0,59,0,0,0,536,0,0,62,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,137,0,0],[0,0,0,0,0,0,0,442,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,439,0,0],[0,0,0,0,0,579,579,494,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,580,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,549,368,550,0,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,0,368,368,0,161,0,162,0,0,0,362,0,0,0,0],[0,0,0,0,581,0,0,0,161,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,500,552,552,22,23,0,24,0,0,0,504,0,0,27,0],[0,0,0,0,555,80,80,22,23,0,0,0,0,0,555,0,0,0,0],[0,0,0,582,91,583,584,22,23,0,24,0,0,585,93,0,0,27,0],[0,553,0,586,0,177,177,22,23,0,24,0,0,0,78,0,553,0,0],[0,553,0,0,0,175,587,0,23,0,24,0,0,0,78,0,553,0,0],[0,0,0,588,91,589,590,22,23,0,24,0,0,591,93,0,0,27,0],[0,0,0,0,513,558,558,32,33,0,34,0,0,0,517,0,0,37,0],[0,0,0,0,561,101,101,32,33,0,0,0,0,0,561,0,0,0,0],[0,0,0,592,112,593,594,32,33,0,34,0,0,595,114,0,0,37,0],[0,559,0,596,0,203,203,32,33,0,34,0,0,0,99,0,559,0,0],[0,559,0,0,0,201,597,0,33,0,34,0,0,0,99,0,559,0,0],[0,0,0,598,112,599,600,32,33,0,34,0,0,601,114,0,0,37,0],[0,0,0,602,66,67,67,8,9,0,10,0,0,0,68,0,0,16,0],[0,0,0,0,165,44,44,8,9,0,0,0,0,566,165,0,0,0,0],[0,0,0,563,66,564,67,8,9,0,10,0,0,566,68,0,0,16,0],[0,0,0,563,66,67,67,8,9,0,10,0,0,0,68,0,0,16,0],[0,527,0,0,0,121,121,0,9,0,10,0,0,0,42,0,527,0,0],[0,527,0,567,0,121,121,0,9,0,10,0,0,0,42,0,527,0,0],[0,0,0,602,66,67,67,8,9,0,10,0,0,0,68,0,0,16,0],[0,0,0,0,165,44,44,8,9,0,0,0,0,572,165,0,0,0,0],[0,0,0,569,66,570,67,8,9,0,10,0,0,572,68,0,0,16,0],[0,0,0,569,66,67,67,8,9,0,10,0,0,0,68,0,0,16,0],[0,0,0,0,532,574,574,57,58,0,59,0,0,0,536,0,0,62,0],[0,0,0,0,577,141,141,57,58,0,0,0,0,0,577,0,0,0,0],[0,0,0,603,152,604,605,57,58,0,59,0,0,606,154,0,0,62,0],[0,575,0,607,0,248,248,57,58,0,59,0,0,0,139,0,575,0,0],[0,575,0,0,0,246,608,0,58,0,59,0,0,0,139,0,575,0,0],[0,0,0,609,152,610,611,57,58,0,59,0,0,612,154,0,0,62,0],[0,0,0,0,0,0,0,494,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,491,0,0],[0,0,0,0,0,0,613,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,614,91,92,92,22,23,0,24,0,0,0,93,0,0,27,0],[0,0,0,0,194,80,80,22,23,0,0,0,0,585,194,0,0,0,0],[0,0,0,582,91,583,92,22,23,0,24,0,0,585,93,0,0,27,0],[0,0,0,582,91,92,92,22,23,0,24,0,0,0,93,0,0,27,0],[0,553,0,0,0,175,175,0,23,0,24,0,0,0,78,0,553,0,0],[0,553,0,586,0,175,175,0,23,0,24,0,0,0,78,0,553,0,0],[0,0,0,614,91,92,92,22,23,0,24,0,0,0,93,0,0,27,0],[0,0,0,0,194,80,80,22,23,0,0,0,0,591,194,0,0,0,0],[0,0,0,588,91,589,92,22,23,0,24,0,0,591,93,0,0,27,0],[0,0,0,588,91,92,92,22,23,0,24,0,0,0,93,0,0,27,0],[0,0,0,615,112,113,113,32,33,0,34,0,0,0,114,0,0,37,0],[0,0,0,0,220,101,101,32,33,0,0,0,0,595,220,0,0,0,0],[0,0,0,592,112,593,113,32,33,0,34,0,0,595,114,0,0,37,0],[0,0,0,592,112,113,113,32,33,0,34,0,0,0,114,0,0,37,0],[0,559,0,0,0,201,201,0,33,0,34,0,0,0,99,0,559,0,0],[0,559,0,596,0,201,201,0,33,0,34,0,0,0,99,0,559,0,0],[0,0,0,615,112,113,113,32,33,0,34,0,0,0,114,0,0,37,0],[0,0,0,0,220,101,101,32,33,0,0,0,0,601,220,0,0,0,0],[0,0,0,598,112,599,113,32,33,0,34,0,0,601,114,0,0,37,0],[0,0,0,598,112,113,113,32,33,0,34,0,0,0,114,0,0,37,0],[0,0,0,0,66,67,67,8,9,0,10,0,0,0,68,0,0,16,0],[0,0,0,616,152,153,153,57,58,0,59,0,0,0,154,0,0,62,0],[0,0,0,0,265,141,141,57,58,0,0,0,0,606,265,0,0,0,0],[0,0,0,603,152,604,153,57,58,0,59,0,0,606,154,0,0,62,0],[0,0,0,603,152,153,153,57,58,0,59,0,0,0,154,0,0,62,0],[0,575,0,0,0,246,246,0,58,0,59,0,0,0,139,0,575,0,0],[0,575,0,607,0,246,246,0,58,0,59,0,0,0,139,0,575,0,0],[0,0,0,616,152,153,153,57,58,0,59,0,0,0,154,0,0,62,0],[0,0,0,0,265,141,141,57,58,0,0,0,0,612,265,0,0,0,0],[0,0,0,609,152,610,153,57,58,0,59,0,0,612,154,0,0,62,0],[0,0,0,609,152,153,153,57,58,0,59,0,0,0,154,0,0,62,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,549,0,0],[0,0,0,0,91,92,92,22,23,0,24,0,0,0,93,0,0,27,0],[0,0,0,0,112,113,113,32,33,0,34,0,0,0,114,0,0,37,0],[0,0,0,0,152,153,153,57,58,0,59,0,0,0,154,0,0,62,0]],\"accepting\":[false,true,true,true,true,true,false,false,true,true,true,true,true,true,true,true,true,true,true,true,false,true,true,true,true,true,true,true,true,true,false,true,true,true,true,true,true,true,true,true,true,true,false,true,false,true,true,false,false,true,true,true,true,true,true,false,false,true,true,true,true,true,true,true,true,true,true,false,true,true,false,true,true,true,false,true,true,true,false,true,false,true,true,false,false,true,true,true,true,true,true,true,false,true,true,false,true,true,true,false,true,false,true,true,false,false,true,true,true,true,true,true,true,false,true,true,true,false,true,true,true,false,true,false,true,true,false,false,false,true,true,false,false,true,true,true,true,true,true,false,true,false,true,true,false,false,true,true,true,true,true,true,true,false,true,true,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,false,true,true,true,false,true,false,true,true,false,false,false,true,true,false,false,true,true,true,false,true,true,true,true,true,true,false,true,true,true,false,true,false,true,true,false,false,false,true,true,false,false,true,true,true,false,true,true,true,true,true,false,true,true,true,true,true,false,true,true,false,false,false,false,true,true,false,false,true,true,true,false,true,true,true,false,true,false,true,true,false,false,false,true,true,false,false,true,true,true,false,true,true,true,true,false,true,false,true,true,true,true,true,true,true,true,true,false,true,true,true,true,true,false,true,true,false,false,false,false,true,true,false,false,true,true,true,false,true,true,true,true,true,false,true,true,false,false,false,false,true,true,false,false,true,true,true,true,false,true,true,true,true,true,true,false,true,true,false,false,false,false,true,false,true,false,true,true,true,true,true,false,true,true,false,false,false,false,true,true,false,false,true,true,true,false,true,true,false,false,true,false,true,true,false,true,true,false,true,true,false,true,true,true,true,true,true,false,true,true,false,false,false,false,true,false,true,true,false,true,true,true,true,true,true,false,true,true,false,false,false,false,true,false,true,false,true,true,true,true,false,false,false,true,true,false,true,true,true,true,true,true,false,true,true,false,false,false,false,true,false,true,false,true,true,false,false,true,true,false,false,true,true,true,false,true,false,true,true,true,true,false,false,false,true,false,true,true,true,true,false,false,false,true,true,false,true,true,true,true,true,true,false,true,true,false,true,false,true,true,true,true,false,false,false,false,false,false,false,true,true,false,false,true,true,false,true,true,true,true,false,true,true,true,true,true,true,false,true,true,false,true,true,false,true,true,true,true,true,true,false,true,true,false,true,false,true,true,true,true,true,true,false,true,true,true,true,true,true,false,true,true,false,false,false,false,false,true,true,false,true,false,true,true,true,true,true,false,true,true,true,true,true,false,true,true,true,true,true,false,true,true,true,false,true,true,true,true,false,false,false,true,false,true,true,true,true,true,false,true,true,true,false,true,true,true,true,true,false,true,true,true,true,false,true,true,true,true,true,false,true,true,false,true,true,true],\"tags\":[[],[\"broken_cluster\"],[\"consonant_syllable\"],[\"vowel_syllable\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"standalone_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"consonant_syllable\"],[\"broken_cluster\"],[\"symbol_cluster\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"symbol_cluster\"],[],[\"symbol_cluster\"],[\"symbol_cluster\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"symbol_cluster\"],[\"symbol_cluster\"],[\"symbol_cluster\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[\"broken_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"broken_cluster\"],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"broken_cluster\"],[\"symbol_cluster\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[],[],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[],[],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[],[],[\"broken_cluster\"],[],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[],[],[],[\"consonant_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[],[],[],[\"vowel_syllable\"],[],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[],[],[\"standalone_cluster\"],[],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[],[],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[],[],[],[],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[],[],[],[\"consonant_syllable\",\"broken_cluster\"],[\"consonant_syllable\",\"broken_cluster\"],[],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[],[],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"consonant_syllable\"],[],[\"consonant_syllable\"],[\"consonant_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"vowel_syllable\"],[],[\"vowel_syllable\"],[\"vowel_syllable\"],[\"broken_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"standalone_cluster\"],[\"standalone_cluster\"],[],[\"consonant_syllable\"],[\"vowel_syllable\"],[\"standalone_cluster\"]]}");
var $79781f8c452881c2$exports = {};
$79781f8c452881c2$exports = JSON.parse("{\"categories\":[\"O\",\"IND\",\"S\",\"GB\",\"B\",\"FM\",\"CGJ\",\"VMAbv\",\"VMPst\",\"VAbv\",\"VPst\",\"CMBlw\",\"VPre\",\"VBlw\",\"H\",\"VMBlw\",\"CMAbv\",\"MBlw\",\"CS\",\"R\",\"SUB\",\"MPst\",\"MPre\",\"FAbv\",\"FPst\",\"FBlw\",\"null\",\"SMAbv\",\"SMBlw\",\"VMPre\",\"ZWNJ\",\"ZWJ\",\"WJ\",\"M\",\"VS\",\"N\",\"HN\",\"MAbv\"],\"decompositions\":{\"2507\":[2503,2494],\"2508\":[2503,2519],\"2888\":[2887,2902],\"2891\":[2887,2878],\"2892\":[2887,2903],\"3018\":[3014,3006],\"3019\":[3015,3006],\"3020\":[3014,3031],\"3144\":[3142,3158],\"3264\":[3263,3285],\"3271\":[3270,3285],\"3272\":[3270,3286],\"3274\":[3270,3266],\"3275\":[3270,3266,3285],\"3402\":[3398,3390],\"3403\":[3399,3390],\"3404\":[3398,3415],\"3546\":[3545,3530],\"3548\":[3545,3535],\"3549\":[3545,3535,3530],\"3550\":[3545,3551],\"3635\":[3661,3634],\"3763\":[3789,3762],\"3955\":[3953,3954],\"3957\":[3953,3956],\"3958\":[4018,3968],\"3959\":[4018,3953,3968],\"3960\":[4019,3968],\"3961\":[4019,3953,3968],\"3969\":[3953,3968],\"6971\":[6970,6965],\"6973\":[6972,6965],\"6976\":[6974,6965],\"6977\":[6975,6965],\"6979\":[6978,6965],\"69934\":[69937,69927],\"69935\":[69938,69927],\"70475\":[70471,70462],\"70476\":[70471,70487],\"70843\":[70841,70842],\"70844\":[70841,70832],\"70846\":[70841,70845],\"71098\":[71096,71087],\"71099\":[71097,71087]},\"stateTable\":[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[2,2,3,4,4,5,0,6,7,8,9,10,11,12,13,14,15,16,0,17,18,11,19,20,21,22,0,0,0,23,0,0,2,0,0,24,0,25],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,28,0,0,0,0,0,27,0,0,0],[0,0,0,0,0,29,0,30,31,32,33,34,35,36,37,38,39,40,0,0,41,35,42,43,44,45,0,0,0,46,0,0,0,0,39,0,0,47],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,0,0,0,0,0,0,14,0,0,0,0,0,0,0,20,21,22,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,21,22,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,8,9,0,0,12,0,14,0,0,0,0,0,0,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,0,9,0,0,0,0,14,0,0,0,0,0,0,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,8,9,10,11,12,13,14,0,16,0,0,18,11,19,20,21,22,0,0,0,23,0,0,0,0,0,0,0,25],[0,0,0,0,0,5,0,6,7,8,9,0,11,12,0,14,0,0,0,0,0,0,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,0,9,0,0,12,0,14,0,0,0,0,0,0,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,0],[0,0,0,0,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,0,7,0,0,0,0,0,0,14,0,0,0,0,0,0,0,20,21,22,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,8,9,10,11,12,13,14,15,16,0,0,18,11,19,20,21,22,0,0,0,23,0,0,0,0,0,0,0,25],[0,0,0,0,0,5,0,6,7,8,9,0,11,12,0,14,0,0,0,0,0,11,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,0],[0,0,0,4,4,5,0,6,7,8,9,10,11,12,13,14,15,16,0,0,18,11,19,20,21,22,0,0,0,23,0,0,0,0,0,0,0,25],[0,0,0,0,0,5,0,6,7,8,9,48,11,12,13,14,48,16,0,0,18,11,19,20,21,22,0,0,0,23,0,0,0,0,49,0,0,25],[0,0,0,0,0,5,0,6,7,8,9,0,11,12,0,14,0,16,0,0,0,11,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,25],[0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,21,22,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,21,22,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,0,0,0,0,0,0,14,0,0,0,0,0,0,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,50,0,51,0],[0,0,0,0,0,5,0,6,7,8,9,0,11,12,0,14,0,16,0,0,0,11,0,20,21,22,0,0,0,23,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,28,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,0,0,0,0,0,0,38,0,0,0,0,0,0,0,43,44,45,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,44,45,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,32,33,0,0,36,0,38,0,0,0,0,0,0,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,0,33,0,0,0,0,38,0,0,0,0,0,0,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,32,33,34,35,36,37,38,0,40,0,0,41,35,42,43,44,45,0,0,0,46,0,0,0,0,0,0,0,47],[0,0,0,0,0,29,0,30,31,32,33,0,35,36,0,38,0,0,0,0,0,0,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,0,33,0,0,36,0,38,0,0,0,0,0,0,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,0],[0,0,0,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,0,31,0,0,0,0,0,0,38,0,0,0,0,0,0,0,43,44,45,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,32,33,34,35,36,37,38,39,40,0,0,41,35,42,43,44,45,0,0,0,46,0,0,0,0,0,0,0,47],[0,0,0,0,0,29,0,30,31,32,33,0,35,36,0,38,0,0,0,0,0,35,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,32,33,52,35,36,37,38,52,40,0,0,41,35,42,43,44,45,0,0,0,46,0,0,0,0,53,0,0,47],[0,0,0,0,0,29,0,30,31,32,33,0,35,36,0,38,0,40,0,0,0,35,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,47],[0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,43,44,45,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,44,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,44,45,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,0,0,0,0,0,0,38,0,0,0,0,0,0,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,0],[0,0,0,0,0,29,0,30,31,32,33,0,35,36,0,38,0,40,0,0,0,35,0,43,44,45,0,0,0,46,0,0,0,0,0,0,0,0],[0,0,0,0,0,5,0,6,7,8,9,48,11,12,13,14,0,16,0,0,18,11,19,20,21,22,0,0,0,23,0,0,0,0,0,0,0,25],[0,0,0,0,0,5,0,6,7,8,9,48,11,12,13,14,48,16,0,0,18,11,19,20,21,22,0,0,0,23,0,0,0,0,0,0,0,25],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,51,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,54,0,0],[0,0,0,0,0,29,0,30,31,32,33,52,35,36,37,38,0,40,0,0,41,35,42,43,44,45,0,0,0,46,0,0,0,0,0,0,0,47],[0,0,0,0,0,29,0,30,31,32,33,52,35,36,37,38,52,40,0,0,41,35,42,43,44,45,0,0,0,46,0,0,0,0,0,0,0,47],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,50,0,51,0]],\"accepting\":[false,true,true,true,true,true,true,true,true,true,true,true,true,false,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true],\"tags\":[[],[\"broken_cluster\"],[\"independent_cluster\"],[\"symbol_cluster\"],[\"standard_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"numeral_cluster\"],[\"broken_cluster\"],[\"independent_cluster\"],[\"symbol_cluster\"],[\"symbol_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"virama_terminated_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"broken_cluster\"],[\"broken_cluster\"],[\"numeral_cluster\"],[\"number_joiner_terminated_cluster\"],[\"standard_cluster\"],[\"standard_cluster\"],[\"numeral_cluster\"]]}");
// Cateories used in the OpenType spec:
// https://www.microsoft.com/typography/otfntdev/devanot/shaping.aspx
const $79e3b6f2c331d0bf$export$a513ea61a7bee91c = {
X: 1,
C: 2,
V: 4,
N: 8,
H: 16,
ZWNJ: 32,
ZWJ: 64,
M: 128,
SM: 256,
VD: 512,
A: 1024,
Placeholder: 2048,
Dotted_Circle: 4096,
RS: 8192,
Coeng: 16384,
Repha: 32768,
Ra: 65536,
CM: 131072,
Symbol: 262144 // Avagraha, etc that take marks (SM,A,VD).
};
const $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0 = {
Start: 1,
Ra_To_Become_Reph: 2,
Pre_M: 4,
Pre_C: 8,
Base_C: 16,
After_Main: 32,
Above_C: 64,
Before_Sub: 128,
Below_C: 256,
After_Sub: 512,
Before_Post: 1024,
Post_C: 2048,
After_Post: 4096,
Final_C: 8192,
SMVD: 16384,
End: 32768
};
const $79e3b6f2c331d0bf$export$8519deaa7de2b07 = $79e3b6f2c331d0bf$export$a513ea61a7bee91c.C | $79e3b6f2c331d0bf$export$a513ea61a7bee91c.Ra | $79e3b6f2c331d0bf$export$a513ea61a7bee91c.CM | $79e3b6f2c331d0bf$export$a513ea61a7bee91c.V | $79e3b6f2c331d0bf$export$a513ea61a7bee91c.Placeholder | $79e3b6f2c331d0bf$export$a513ea61a7bee91c.Dotted_Circle;
const $79e3b6f2c331d0bf$export$bbcd928767338e0d = $79e3b6f2c331d0bf$export$a513ea61a7bee91c.ZWJ | $79e3b6f2c331d0bf$export$a513ea61a7bee91c.ZWNJ;
const $79e3b6f2c331d0bf$export$ca9599b2a300afc = $79e3b6f2c331d0bf$export$a513ea61a7bee91c.H | $79e3b6f2c331d0bf$export$a513ea61a7bee91c.Coeng;
const $79e3b6f2c331d0bf$export$e99d119da76a0fc5 = {
Default: {
hasOldSpec: false,
virama: 0,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.Before_Post,
rephMode: 'Implicit',
blwfMode: 'Pre_And_Post'
},
Devanagari: {
hasOldSpec: true,
virama: 0x094D,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.Before_Post,
rephMode: 'Implicit',
blwfMode: 'Pre_And_Post'
},
Bengali: {
hasOldSpec: true,
virama: 0x09CD,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.After_Sub,
rephMode: 'Implicit',
blwfMode: 'Pre_And_Post'
},
Gurmukhi: {
hasOldSpec: true,
virama: 0x0A4D,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.Before_Sub,
rephMode: 'Implicit',
blwfMode: 'Pre_And_Post'
},
Gujarati: {
hasOldSpec: true,
virama: 0x0ACD,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.Before_Post,
rephMode: 'Implicit',
blwfMode: 'Pre_And_Post'
},
Oriya: {
hasOldSpec: true,
virama: 0x0B4D,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.After_Main,
rephMode: 'Implicit',
blwfMode: 'Pre_And_Post'
},
Tamil: {
hasOldSpec: true,
virama: 0x0BCD,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.After_Post,
rephMode: 'Implicit',
blwfMode: 'Pre_And_Post'
},
Telugu: {
hasOldSpec: true,
virama: 0x0C4D,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.After_Post,
rephMode: 'Explicit',
blwfMode: 'Post_Only'
},
Kannada: {
hasOldSpec: true,
virama: 0x0CCD,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.After_Post,
rephMode: 'Implicit',
blwfMode: 'Post_Only'
},
Malayalam: {
hasOldSpec: true,
virama: 0x0D4D,
basePos: 'Last',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.After_Main,
rephMode: 'Log_Repha',
blwfMode: 'Pre_And_Post'
},
// Handled by UniversalShaper
// Sinhala: {
// hasOldSpec: false,
// virama: 0x0DCA,
// basePos: 'Last_Sinhala',
// rephPos: POSITIONS.After_Main,
// rephMode: 'Explicit',
// blwfMode: 'Pre_And_Post'
// },
Khmer: {
hasOldSpec: false,
virama: 0x17D2,
basePos: 'First',
rephPos: $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0.Ra_To_Become_Reph,
rephMode: 'Vis_Repha',
blwfMode: 'Pre_And_Post'
}
};
const $79e3b6f2c331d0bf$export$f647c9cfdd77d95a = {
// Khmer
0x17BE: [
0x17C1,
0x17BE
],
0x17BF: [
0x17C1,
0x17BF
],
0x17C0: [
0x17C1,
0x17C0
],
0x17C4: [
0x17C1,
0x17C4
],
0x17C5: [
0x17C1,
0x17C5
]
};
const { decompositions: $d203e6b9523d0071$var$decompositions } = (0, (/*@__PURE__*/$parcel$interopDefault($79781f8c452881c2$exports)));
const $d203e6b9523d0071$var$trie = new (0, ($parcel$interopDefault($gfJaN$unicodetrie)))((0, $66a5b9fb5318558a$export$94fdf11bafc8de6b)("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"));
const $d203e6b9523d0071$var$stateMachine = new (0, ($parcel$interopDefault($gfJaN$dfa)))((0, (/*@__PURE__*/$parcel$interopDefault($d22b56f2cf15e5ba$exports))));
class $d203e6b9523d0071$export$2e2bcd8739ae039 extends (0, $d28fb665ee343afc$export$2e2bcd8739ae039) {
static planFeatures(plan) {
plan.addStage($d203e6b9523d0071$var$setupSyllables);
plan.addStage([
'locl',
'ccmp'
]);
plan.addStage($d203e6b9523d0071$var$initialReordering);
plan.addStage('nukt');
plan.addStage('akhn');
plan.addStage('rphf', false);
plan.addStage('rkrf');
plan.addStage('pref', false);
plan.addStage('blwf', false);
plan.addStage('abvf', false);
plan.addStage('half', false);
plan.addStage('pstf', false);
plan.addStage('vatu');
plan.addStage('cjct');
plan.addStage('cfar', false);
plan.addStage($d203e6b9523d0071$var$finalReordering);
plan.addStage({
local: [
'init'
],
global: [
'pres',
'abvs',
'blws',
'psts',
'haln',
'dist',
'abvm',
'blwm',
'calt',
'clig'
]
});
// Setup the indic config for the selected script
plan.unicodeScript = $e38a1a895f6aeb54$export$ce50e82f12a827a4(plan.script);
plan.indicConfig = (0, $79e3b6f2c331d0bf$export$e99d119da76a0fc5)[plan.unicodeScript] || (0, $79e3b6f2c331d0bf$export$e99d119da76a0fc5).Default;
plan.isOldSpec = plan.indicConfig.hasOldSpec && plan.script[plan.script.length - 1] !== '2';
// TODO: turn off kern (Khmer) and liga features.
}
static assignFeatures(plan, glyphs) {
// Decompose split matras
// TODO: do this in a more general unicode normalizer
for(let i = glyphs.length - 1; i >= 0; i--){
let codepoint = glyphs[i].codePoints[0];
let d = (0, $79e3b6f2c331d0bf$export$f647c9cfdd77d95a)[codepoint] || $d203e6b9523d0071$var$decompositions[codepoint];
if (d) {
let decomposed = d.map((c)=>{
let g = plan.font.glyphForCodePoint(c);
return new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(plan.font, g.id, [
c
], glyphs[i].features);
});
glyphs.splice(i, 1, ...decomposed);
}
}
}
}
(0, $gfJaN$swchelperscjs_define_propertycjs._)($d203e6b9523d0071$export$2e2bcd8739ae039, "zeroMarkWidths", 'NONE');
function $d203e6b9523d0071$var$indicCategory(glyph) {
return $d203e6b9523d0071$var$trie.get(glyph.codePoints[0]) >> 8;
}
function $d203e6b9523d0071$var$indicPosition(glyph) {
return 1 << ($d203e6b9523d0071$var$trie.get(glyph.codePoints[0]) & 0xff);
}
class $d203e6b9523d0071$var$IndicInfo {
constructor(category, position, syllableType, syllable){
this.category = category;
this.position = position;
this.syllableType = syllableType;
this.syllable = syllable;
}
}
function $d203e6b9523d0071$var$setupSyllables(font, glyphs) {
let syllable = 0;
let last = 0;
for (let [start, end, tags] of $d203e6b9523d0071$var$stateMachine.match(glyphs.map($d203e6b9523d0071$var$indicCategory))){
if (start > last) {
++syllable;
for(let i = last; i < start; i++)glyphs[i].shaperInfo = new $d203e6b9523d0071$var$IndicInfo((0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).X, (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).End, 'non_indic_cluster', syllable);
}
++syllable;
// Create shaper info
for(let i = start; i <= end; i++)glyphs[i].shaperInfo = new $d203e6b9523d0071$var$IndicInfo(1 << $d203e6b9523d0071$var$indicCategory(glyphs[i]), $d203e6b9523d0071$var$indicPosition(glyphs[i]), tags[0], syllable);
last = end + 1;
}
if (last < glyphs.length) {
++syllable;
for(let i = last; i < glyphs.length; i++)glyphs[i].shaperInfo = new $d203e6b9523d0071$var$IndicInfo((0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).X, (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).End, 'non_indic_cluster', syllable);
}
}
function $d203e6b9523d0071$var$isConsonant(glyph) {
return glyph.shaperInfo.category & (0, $79e3b6f2c331d0bf$export$8519deaa7de2b07);
}
function $d203e6b9523d0071$var$isJoiner(glyph) {
return glyph.shaperInfo.category & (0, $79e3b6f2c331d0bf$export$bbcd928767338e0d);
}
function $d203e6b9523d0071$var$isHalantOrCoeng(glyph) {
return glyph.shaperInfo.category & (0, $79e3b6f2c331d0bf$export$ca9599b2a300afc);
}
function $d203e6b9523d0071$var$wouldSubstitute(glyphs, feature) {
for (let glyph of glyphs)glyph.features = {
[feature]: true
};
let GSUB = glyphs[0]._font._layoutEngine.engine.GSUBProcessor;
GSUB.applyFeatures([
feature
], glyphs);
return glyphs.length === 1;
}
function $d203e6b9523d0071$var$consonantPosition(font, consonant, virama) {
let glyphs = [
virama,
consonant,
virama
];
if ($d203e6b9523d0071$var$wouldSubstitute(glyphs.slice(0, 2), 'blwf') || $d203e6b9523d0071$var$wouldSubstitute(glyphs.slice(1, 3), 'blwf')) return (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Below_C;
else if ($d203e6b9523d0071$var$wouldSubstitute(glyphs.slice(0, 2), 'pstf') || $d203e6b9523d0071$var$wouldSubstitute(glyphs.slice(1, 3), 'pstf')) return (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Post_C;
else if ($d203e6b9523d0071$var$wouldSubstitute(glyphs.slice(0, 2), 'pref') || $d203e6b9523d0071$var$wouldSubstitute(glyphs.slice(1, 3), 'pref')) return (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Post_C;
return (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Base_C;
}
function $d203e6b9523d0071$var$initialReordering(font, glyphs, plan) {
let indicConfig = plan.indicConfig;
let features = font._layoutEngine.engine.GSUBProcessor.features;
let dottedCircle = font.glyphForCodePoint(0x25cc).id;
let virama = font.glyphForCodePoint(indicConfig.virama).id;
if (virama) {
let info = new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(font, virama, [
indicConfig.virama
]);
for(let i = 0; i < glyphs.length; i++)if (glyphs[i].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Base_C) glyphs[i].shaperInfo.position = $d203e6b9523d0071$var$consonantPosition(font, glyphs[i].copy(), info);
}
for(let start = 0, end = $d203e6b9523d0071$var$nextSyllable(glyphs, 0); start < glyphs.length; start = end, end = $d203e6b9523d0071$var$nextSyllable(glyphs, start)){
let { category: category, syllableType: syllableType } = glyphs[start].shaperInfo;
if (syllableType === 'symbol_cluster' || syllableType === 'non_indic_cluster') continue;
if (syllableType === 'broken_cluster' && dottedCircle) {
let g = new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(font, dottedCircle, [
0x25cc
]);
g.shaperInfo = new $d203e6b9523d0071$var$IndicInfo(1 << $d203e6b9523d0071$var$indicCategory(g), $d203e6b9523d0071$var$indicPosition(g), glyphs[start].shaperInfo.syllableType, glyphs[start].shaperInfo.syllable);
// Insert after possible Repha.
let i = start;
while(i < end && glyphs[i].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).Repha)i++;
glyphs.splice(i++, 0, g);
end++;
}
// 1. Find base consonant:
//
// The shaping engine finds the base consonant of the syllable, using the
// following algorithm: starting from the end of the syllable, move backwards
// until a consonant is found that does not have a below-base or post-base
// form (post-base forms have to follow below-base forms), or that is not a
// pre-base reordering Ra, or arrive at the first consonant. The consonant
// stopped at will be the base.
let base = end;
let limit = start;
let hasReph = false;
// If the syllable starts with Ra + Halant (in a script that has Reph)
// and has more than one consonant, Ra is excluded from candidates for
// base consonants.
if (indicConfig.rephPos !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Ra_To_Become_Reph && features.rphf && start + 3 <= end && (indicConfig.rephMode === 'Implicit' && !$d203e6b9523d0071$var$isJoiner(glyphs[start + 2]) || indicConfig.rephMode === 'Explicit' && glyphs[start + 2].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).ZWJ)) {
// See if it matches the 'rphf' feature.
let g = [
glyphs[start].copy(),
glyphs[start + 1].copy(),
glyphs[start + 2].copy()
];
if ($d203e6b9523d0071$var$wouldSubstitute(g.slice(0, 2), 'rphf') || indicConfig.rephMode === 'Explicit' && $d203e6b9523d0071$var$wouldSubstitute(g, 'rphf')) {
limit += 2;
while(limit < end && $d203e6b9523d0071$var$isJoiner(glyphs[limit]))limit++;
base = start;
hasReph = true;
}
} else if (indicConfig.rephMode === 'Log_Repha' && glyphs[start].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).Repha) {
limit++;
while(limit < end && $d203e6b9523d0071$var$isJoiner(glyphs[limit]))limit++;
base = start;
hasReph = true;
}
switch(indicConfig.basePos){
case 'Last':
{
// starting from the end of the syllable, move backwards
let i = end;
let seenBelow = false;
do {
let info = glyphs[--i].shaperInfo;
// until a consonant is found
if ($d203e6b9523d0071$var$isConsonant(glyphs[i])) {
// that does not have a below-base or post-base form
// (post-base forms have to follow below-base forms),
if (info.position !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Below_C && (info.position !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Post_C || seenBelow)) {
base = i;
break;
}
// or that is not a pre-base reordering Ra,
//
// IMPLEMENTATION NOTES:
//
// Our pre-base reordering Ra's are marked POS_POST_C, so will be skipped
// by the logic above already.
//
// or arrive at the first consonant. The consonant stopped at will
// be the base.
if (info.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Below_C) seenBelow = true;
base = i;
} else if (start < i && info.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).ZWJ && glyphs[i - 1].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).H) break;
}while (i > limit);
break;
}
case 'First':
// The first consonant is always the base.
base = start;
// Mark all subsequent consonants as below.
for(let i = base + 1; i < end; i++)if ($d203e6b9523d0071$var$isConsonant(glyphs[i])) glyphs[i].shaperInfo.position = (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Below_C;
}
// If the syllable starts with Ra + Halant (in a script that has Reph)
// and has more than one consonant, Ra is excluded from candidates for
// base consonants.
//
// Only do this for unforced Reph. (ie. not for Ra,H,ZWJ)
if (hasReph && base === start && limit - base <= 2) hasReph = false;
// 2. Decompose and reorder Matras:
//
// Each matra and any syllable modifier sign in the cluster are moved to the
// appropriate position relative to the consonant(s) in the cluster. The
// shaping engine decomposes two- or three-part matras into their constituent
// parts before any repositioning. Matra characters are classified by which
// consonant in a conjunct they have affinity for and are reordered to the
// following positions:
//
// o Before first half form in the syllable
// o After subjoined consonants
// o After post-form consonant
// o After main consonant (for above marks)
//
// IMPLEMENTATION NOTES:
//
// The normalize() routine has already decomposed matras for us, so we don't
// need to worry about that.
// 3. Reorder marks to canonical order:
//
// Adjacent nukta and halant or nukta and vedic sign are always repositioned
// if necessary, so that the nukta is first.
//
// IMPLEMENTATION NOTES:
//
// We don't need to do this: the normalize() routine already did this for us.
// Reorder characters
for(let i = start; i < base; i++){
let info = glyphs[i].shaperInfo;
info.position = Math.min((0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Pre_C, info.position);
}
if (base < end) glyphs[base].shaperInfo.position = (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Base_C;
// Mark final consonants. A final consonant is one appearing after a matra,
// like in Khmer.
for(let i = base + 1; i < end; i++)if (glyphs[i].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).M) {
for(let j = i + 1; j < end; j++)if ($d203e6b9523d0071$var$isConsonant(glyphs[j])) {
glyphs[j].shaperInfo.position = (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Final_C;
break;
}
break;
}
// Handle beginning Ra
if (hasReph) glyphs[start].shaperInfo.position = (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Ra_To_Become_Reph;
// For old-style Indic script tags, move the first post-base Halant after
// last consonant.
//
// Reports suggest that in some scripts Uniscribe does this only if there
// is *not* a Halant after last consonant already (eg. Kannada), while it
// does it unconditionally in other scripts (eg. Malayalam). We don't
// currently know about other scripts, so we single out Malayalam for now.
//
// Kannada test case:
// U+0C9A,U+0CCD,U+0C9A,U+0CCD
// With some versions of Lohit Kannada.
// https://bugs.freedesktop.org/show_bug.cgi?id=59118
//
// Malayalam test case:
// U+0D38,U+0D4D,U+0D31,U+0D4D,U+0D31,U+0D4D
// With lohit-ttf-20121122/Lohit-Malayalam.ttf
if (plan.isOldSpec) {
let disallowDoubleHalants = plan.unicodeScript !== 'Malayalam';
for(let i = base + 1; i < end; i++)if (glyphs[i].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).H) {
let j;
for(j = end - 1; j > i; j--){
if ($d203e6b9523d0071$var$isConsonant(glyphs[j]) || disallowDoubleHalants && glyphs[j].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).H) break;
}
if (glyphs[j].shaperInfo.category !== (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).H && j > i) {
// Move Halant to after last consonant.
let t = glyphs[i];
glyphs.splice(i, 0, ...glyphs.splice(i + 1, j - i));
glyphs[j] = t;
}
break;
}
}
// Attach misc marks to previous char to move with them.
let lastPos = (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Start;
for(let i = start; i < end; i++){
let info = glyphs[i].shaperInfo;
if (info.category & ((0, $79e3b6f2c331d0bf$export$bbcd928767338e0d) | (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).N | (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).RS | (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).CM | (0, $79e3b6f2c331d0bf$export$ca9599b2a300afc) & info.category)) {
info.position = lastPos;
if (info.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).H && info.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Pre_M) {
// Uniscribe doesn't move the Halant with Left Matra.
// TEST: U+092B,U+093F,U+094DE
// We follow. This is important for the Sinhala
// U+0DDA split matra since it decomposes to U+0DD9,U+0DCA
// where U+0DD9 is a left matra and U+0DCA is the virama.
// We don't want to move the virama with the left matra.
// TEST: U+0D9A,U+0DDA
for(let j = i; j > start; j--)if (glyphs[j - 1].shaperInfo.position !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Pre_M) {
info.position = glyphs[j - 1].shaperInfo.position;
break;
}
}
} else if (info.position !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).SMVD) lastPos = info.position;
}
// For post-base consonants let them own anything before them
// since the last consonant or matra.
let last = base;
for(let i = base + 1; i < end; i++){
if ($d203e6b9523d0071$var$isConsonant(glyphs[i])) {
for(let j = last + 1; j < i; j++)if (glyphs[j].shaperInfo.position < (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).SMVD) glyphs[j].shaperInfo.position = glyphs[i].shaperInfo.position;
last = i;
} else if (glyphs[i].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).M) last = i;
}
let arr = glyphs.slice(start, end);
arr.sort((a, b)=>a.shaperInfo.position - b.shaperInfo.position);
glyphs.splice(start, arr.length, ...arr);
// Find base again
for(let i = start; i < end; i++)if (glyphs[i].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Base_C) {
base = i;
break;
}
// Setup features now
// Reph
for(let i = start; i < end && glyphs[i].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Ra_To_Become_Reph; i++)glyphs[i].features.rphf = true;
// Pre-base
let blwf = !plan.isOldSpec && indicConfig.blwfMode === 'Pre_And_Post';
for(let i = start; i < base; i++){
glyphs[i].features.half = true;
if (blwf) glyphs[i].features.blwf = true;
}
// Post-base
for(let i = base + 1; i < end; i++){
glyphs[i].features.abvf = true;
glyphs[i].features.pstf = true;
glyphs[i].features.blwf = true;
}
if (plan.isOldSpec && plan.unicodeScript === 'Devanagari') {
// Old-spec eye-lash Ra needs special handling. From the
// spec:
//
// "The feature 'below-base form' is applied to consonants
// having below-base forms and following the base consonant.
// The exception is vattu, which may appear below half forms
// as well as below the base glyph. The feature 'below-base
// form' will be applied to all such occurrences of Ra as well."
//
// Test case: U+0924,U+094D,U+0930,U+094d,U+0915
// with Sanskrit 2003 font.
//
// However, note that Ra,Halant,ZWJ is the correct way to
// request eyelash form of Ra, so we wouldbn't inhibit it
// in that sequence.
//
// Test case: U+0924,U+094D,U+0930,U+094d,U+200D,U+0915
for(let i = start; i + 1 < base; i++)if (glyphs[i].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).Ra && glyphs[i + 1].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).H && (i + 1 === base || glyphs[i + 2].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).ZWJ)) {
glyphs[i].features.blwf = true;
glyphs[i + 1].features.blwf = true;
}
}
let prefLen = 2;
if (features.pref && base + prefLen < end) // Find a Halant,Ra sequence and mark it for pre-base reordering processing.
for(let i = base + 1; i + prefLen - 1 < end; i++){
let g = [
glyphs[i].copy(),
glyphs[i + 1].copy()
];
if ($d203e6b9523d0071$var$wouldSubstitute(g, 'pref')) {
for(let j = 0; j < prefLen; j++)glyphs[i++].features.pref = true;
// Mark the subsequent stuff with 'cfar'. Used in Khmer.
// Read the feature spec.
// This allows distinguishing the following cases with MS Khmer fonts:
// U+1784,U+17D2,U+179A,U+17D2,U+1782
// U+1784,U+17D2,U+1782,U+17D2,U+179A
if (features.cfar) for(; i < end; i++)glyphs[i].features.cfar = true;
break;
}
}
// Apply ZWJ/ZWNJ effects
for(let i = start + 1; i < end; i++)if ($d203e6b9523d0071$var$isJoiner(glyphs[i])) {
let nonJoiner = glyphs[i].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).ZWNJ;
let j = i;
do {
j--;
// ZWJ/ZWNJ should disable CJCT. They do that by simply
// being there, since we don't skip them for the CJCT
// feature (ie. F_MANUAL_ZWJ)
// A ZWNJ disables HALF.
if (nonJoiner) delete glyphs[j].features.half;
}while (j > start && !$d203e6b9523d0071$var$isConsonant(glyphs[j]));
}
}
}
function $d203e6b9523d0071$var$finalReordering(font, glyphs, plan) {
let indicConfig = plan.indicConfig;
let features = font._layoutEngine.engine.GSUBProcessor.features;
for(let start = 0, end = $d203e6b9523d0071$var$nextSyllable(glyphs, 0); start < glyphs.length; start = end, end = $d203e6b9523d0071$var$nextSyllable(glyphs, start)){
// 4. Final reordering:
//
// After the localized forms and basic shaping forms GSUB features have been
// applied (see below), the shaping engine performs some final glyph
// reordering before applying all the remaining font features to the entire
// cluster.
let tryPref = !!features.pref;
// Find base again
let base = start;
for(; base < end; base++)if (glyphs[base].shaperInfo.position >= (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Base_C) {
if (tryPref && base + 1 < end) {
for(let i = base + 1; i < end; i++)if (glyphs[i].features.pref) {
if (!(glyphs[i].substituted && glyphs[i].isLigated && !glyphs[i].isMultiplied)) {
// Ok, this was a 'pref' candidate but didn't form any.
// Base is around here...
base = i;
while(base < end && $d203e6b9523d0071$var$isHalantOrCoeng(glyphs[base]))base++;
glyphs[base].shaperInfo.position = (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).BASE_C;
tryPref = false;
}
break;
}
}
// For Malayalam, skip over unformed below- (but NOT post-) forms.
if (plan.unicodeScript === 'Malayalam') for(let i = base + 1; i < end; i++){
while(i < end && $d203e6b9523d0071$var$isJoiner(glyphs[i]))i++;
if (i === end || !$d203e6b9523d0071$var$isHalantOrCoeng(glyphs[i])) break;
i++; // Skip halant.
while(i < end && $d203e6b9523d0071$var$isJoiner(glyphs[i]))i++;
if (i < end && $d203e6b9523d0071$var$isConsonant(glyphs[i]) && glyphs[i].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Below_C) {
base = i;
glyphs[base].shaperInfo.position = (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Base_C;
}
}
if (start < base && glyphs[base].shaperInfo.position > (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Base_C) base--;
break;
}
if (base === end && start < base && glyphs[base - 1].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).ZWJ) base--;
if (base < end) while(start < base && glyphs[base].shaperInfo.category & ((0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).N | (0, $79e3b6f2c331d0bf$export$ca9599b2a300afc)))base--;
// o Reorder matras:
//
// If a pre-base matra character had been reordered before applying basic
// features, the glyph can be moved closer to the main consonant based on
// whether half-forms had been formed. Actual position for the matra is
// defined as “after last standalone halant glyph, after initial matra
// position and before the main consonant”. If ZWJ or ZWNJ follow this
// halant, position is moved after it.
//
if (start + 1 < end && start < base) {
// If we lost track of base, alas, position before last thingy.
let newPos = base === end ? base - 2 : base - 1;
// Malayalam / Tamil do not have "half" forms or explicit virama forms.
// The glyphs formed by 'half' are Chillus or ligated explicit viramas.
// We want to position matra after them.
if (plan.unicodeScript !== 'Malayalam' && plan.unicodeScript !== 'Tamil') {
while(newPos > start && !(glyphs[newPos].shaperInfo.category & ((0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).M | (0, $79e3b6f2c331d0bf$export$ca9599b2a300afc))))newPos--;
// If we found no Halant we are done.
// Otherwise only proceed if the Halant does
// not belong to the Matra itself!
if ($d203e6b9523d0071$var$isHalantOrCoeng(glyphs[newPos]) && glyphs[newPos].shaperInfo.position !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Pre_M) // If ZWJ or ZWNJ follow this halant, position is moved after it.
{
if (newPos + 1 < end && $d203e6b9523d0071$var$isJoiner(glyphs[newPos + 1])) newPos++;
} else newPos = start; // No move.
}
if (start < newPos && glyphs[newPos].shaperInfo.position !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Pre_M) {
// Now go see if there's actually any matras...
for(let i = newPos; i > start; i--)if (glyphs[i - 1].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Pre_M) {
let oldPos = i - 1;
if (oldPos < base && base <= newPos) base--;
let tmp = glyphs[oldPos];
glyphs.splice(oldPos, 0, ...glyphs.splice(oldPos + 1, newPos - oldPos));
glyphs[newPos] = tmp;
newPos--;
}
}
}
// o Reorder reph:
//
// Reph’s original position is always at the beginning of the syllable,
// (i.e. it is not reordered at the character reordering stage). However,
// it will be reordered according to the basic-forms shaping results.
// Possible positions for reph, depending on the script, are; after main,
// before post-base consonant forms, and after post-base consonant forms.
// Two cases:
//
// - If repha is encoded as a sequence of characters (Ra,H or Ra,H,ZWJ), then
// we should only move it if the sequence ligated to the repha form.
//
// - If repha is encoded separately and in the logical position, we should only
// move it if it did NOT ligate. If it ligated, it's probably the font trying
// to make it work without the reordering.
if (start + 1 < end && glyphs[start].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Ra_To_Become_Reph && glyphs[start].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).Repha !== (glyphs[start].isLigated && !glyphs[start].isMultiplied)) {
let newRephPos;
let rephPos = indicConfig.rephPos;
let found = false;
// 1. If reph should be positioned after post-base consonant forms,
// proceed to step 5.
if (rephPos !== (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).After_Post) {
// 2. If the reph repositioning class is not after post-base: target
// position is after the first explicit halant glyph between the
// first post-reph consonant and last main consonant. If ZWJ or ZWNJ
// are following this halant, position is moved after it. If such
// position is found, this is the target position. Otherwise,
// proceed to the next step.
//
// Note: in old-implementation fonts, where classifications were
// fixed in shaping engine, there was no case where reph position
// will be found on this step.
newRephPos = start + 1;
while(newRephPos < base && !$d203e6b9523d0071$var$isHalantOrCoeng(glyphs[newRephPos]))newRephPos++;
if (newRephPos < base && $d203e6b9523d0071$var$isHalantOrCoeng(glyphs[newRephPos])) {
// ->If ZWJ or ZWNJ are following this halant, position is moved after it.
if (newRephPos + 1 < base && $d203e6b9523d0071$var$isJoiner(glyphs[newRephPos + 1])) newRephPos++;
found = true;
}
// 3. If reph should be repositioned after the main consonant: find the
// first consonant not ligated with main, or find the first
// consonant that is not a potential pre-base reordering Ra.
if (!found && rephPos === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).After_Main) {
newRephPos = base;
while(newRephPos + 1 < end && glyphs[newRephPos + 1].shaperInfo.position <= (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).After_Main)newRephPos++;
found = newRephPos < end;
}
// 4. If reph should be positioned before post-base consonant, find
// first post-base classified consonant not ligated with main. If no
// consonant is found, the target position should be before the
// first matra, syllable modifier sign or vedic sign.
//
// This is our take on what step 4 is trying to say (and failing, BADLY).
if (!found && rephPos === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).After_Sub) {
newRephPos = base;
while(newRephPos + 1 < end && !(glyphs[newRephPos + 1].shaperInfo.position & ((0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Post_C | (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).After_Post | (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).SMVD)))newRephPos++;
found = newRephPos < end;
}
}
// 5. If no consonant is found in steps 3 or 4, move reph to a position
// immediately before the first post-base matra, syllable modifier
// sign or vedic sign that has a reordering class after the intended
// reph position. For example, if the reordering position for reph
// is post-main, it will skip above-base matras that also have a
// post-main position.
if (!found) {
// Copied from step 2.
newRephPos = start + 1;
while(newRephPos < base && !$d203e6b9523d0071$var$isHalantOrCoeng(glyphs[newRephPos]))newRephPos++;
if (newRephPos < base && $d203e6b9523d0071$var$isHalantOrCoeng(glyphs[newRephPos])) {
// ->If ZWJ or ZWNJ are following this halant, position is moved after it.
if (newRephPos + 1 < base && $d203e6b9523d0071$var$isJoiner(glyphs[newRephPos + 1])) newRephPos++;
found = true;
}
}
// 6. Otherwise, reorder reph to the end of the syllable.
if (!found) {
newRephPos = end - 1;
while(newRephPos > start && glyphs[newRephPos].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).SMVD)newRephPos--;
// If the Reph is to be ending up after a Matra,Halant sequence,
// position it before that Halant so it can interact with the Matra.
// However, if it's a plain Consonant,Halant we shouldn't do that.
// Uniscribe doesn't do this.
// TEST: U+0930,U+094D,U+0915,U+094B,U+094D
if ($d203e6b9523d0071$var$isHalantOrCoeng(glyphs[newRephPos])) {
for(let i = base + 1; i < newRephPos; i++)if (glyphs[i].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).M) newRephPos--;
}
}
let reph = glyphs[start];
glyphs.splice(start, 0, ...glyphs.splice(start + 1, newRephPos - start));
glyphs[newRephPos] = reph;
if (start < base && base <= newRephPos) base--;
}
// o Reorder pre-base reordering consonants:
//
// If a pre-base reordering consonant is found, reorder it according to
// the following rules:
if (tryPref && base + 1 < end) {
for(let i = base + 1; i < end; i++)if (glyphs[i].features.pref) {
// 1. Only reorder a glyph produced by substitution during application
// of the <pref> feature. (Note that a font may shape a Ra consonant with
// the feature generally but block it in certain contexts.)
// Note: We just check that something got substituted. We don't check that
// the <pref> feature actually did it...
//
// Reorder pref only if it ligated.
if (glyphs[i].isLigated && !glyphs[i].isMultiplied) {
// 2. Try to find a target position the same way as for pre-base matra.
// If it is found, reorder pre-base consonant glyph.
//
// 3. If position is not found, reorder immediately before main
// consonant.
let newPos = base;
// Malayalam / Tamil do not have "half" forms or explicit virama forms.
// The glyphs formed by 'half' are Chillus or ligated explicit viramas.
// We want to position matra after them.
if (plan.unicodeScript !== 'Malayalam' && plan.unicodeScript !== 'Tamil') {
while(newPos > start && !(glyphs[newPos - 1].shaperInfo.category & ((0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).M | (0, $79e3b6f2c331d0bf$export$ca9599b2a300afc))))newPos--;
// In Khmer coeng model, a H,Ra can go *after* matras. If it goes after a
// split matra, it should be reordered to *before* the left part of such matra.
if (newPos > start && glyphs[newPos - 1].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).M) {
let oldPos = i;
for(let j = base + 1; j < oldPos; j++)if (glyphs[j].shaperInfo.category === (0, $79e3b6f2c331d0bf$export$a513ea61a7bee91c).M) {
newPos--;
break;
}
}
}
if (newPos > start && $d203e6b9523d0071$var$isHalantOrCoeng(glyphs[newPos - 1])) // -> If ZWJ or ZWNJ follow this halant, position is moved after it.
{
if (newPos < end && $d203e6b9523d0071$var$isJoiner(glyphs[newPos])) newPos++;
}
let oldPos = i;
let tmp = glyphs[oldPos];
glyphs.splice(newPos + 1, 0, ...glyphs.splice(newPos, oldPos - newPos));
glyphs[newPos] = tmp;
if (newPos <= base && base < oldPos) base++;
}
break;
}
}
// Apply 'init' to the Left Matra if it's a word start.
if (glyphs[start].shaperInfo.position === (0, $79e3b6f2c331d0bf$export$1a1f61c9c4dd9df0).Pre_M && (!start || !/Cf|Mn/.test((0, $gfJaN$unicodeproperties.getCategory)(glyphs[start - 1].codePoints[0])))) glyphs[start].features.init = true;
}
}
function $d203e6b9523d0071$var$nextSyllable(glyphs, start) {
if (start >= glyphs.length) return start;
let syllable = glyphs[start].shaperInfo.syllable;
while(++start < glyphs.length && glyphs[start].shaperInfo.syllable === syllable);
return start;
}
const { categories: $9b772791ccede8a5$var$categories, decompositions: $9b772791ccede8a5$var$decompositions } = (0, (/*@__PURE__*/$parcel$interopDefault($79781f8c452881c2$exports)));
const $9b772791ccede8a5$var$trie = new (0, ($parcel$interopDefault($gfJaN$unicodetrie)))((0, $66a5b9fb5318558a$export$94fdf11bafc8de6b)("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"));
const $9b772791ccede8a5$var$stateMachine = new (0, ($parcel$interopDefault($gfJaN$dfa)))((0, (/*@__PURE__*/$parcel$interopDefault($79781f8c452881c2$exports))));
class $9b772791ccede8a5$export$2e2bcd8739ae039 extends (0, $d28fb665ee343afc$export$2e2bcd8739ae039) {
static planFeatures(plan) {
plan.addStage($9b772791ccede8a5$var$setupSyllables);
// Default glyph pre-processing group
plan.addStage([
'locl',
'ccmp',
'nukt',
'akhn'
]);
// Reordering group
plan.addStage($9b772791ccede8a5$var$clearSubstitutionFlags);
plan.addStage([
'rphf'
], false);
plan.addStage($9b772791ccede8a5$var$recordRphf);
plan.addStage($9b772791ccede8a5$var$clearSubstitutionFlags);
plan.addStage([
'pref'
]);
plan.addStage($9b772791ccede8a5$var$recordPref);
// Orthographic unit shaping group
plan.addStage([
'rkrf',
'abvf',
'blwf',
'half',
'pstf',
'vatu',
'cjct'
]);
plan.addStage($9b772791ccede8a5$var$reorder);
// Topographical features
// Scripts that need this are handled by the Arabic shaper, not implemented here for now.
// plan.addStage(['isol', 'init', 'medi', 'fina', 'med2', 'fin2', 'fin3'], false);
// Standard topographic presentation and positional feature application
plan.addStage([
'abvs',
'blws',
'pres',
'psts',
'dist',
'abvm',
'blwm'
]);
}
static assignFeatures(plan, glyphs) {
// Decompose split vowels
// TODO: do this in a more general unicode normalizer
for(let i = glyphs.length - 1; i >= 0; i--){
let codepoint = glyphs[i].codePoints[0];
if ($9b772791ccede8a5$var$decompositions[codepoint]) {
let decomposed = $9b772791ccede8a5$var$decompositions[codepoint].map((c)=>{
let g = plan.font.glyphForCodePoint(c);
return new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(plan.font, g.id, [
c
], glyphs[i].features);
});
glyphs.splice(i, 1, ...decomposed);
}
}
}
}
(0, $gfJaN$swchelperscjs_define_propertycjs._)($9b772791ccede8a5$export$2e2bcd8739ae039, "zeroMarkWidths", 'BEFORE_GPOS');
function $9b772791ccede8a5$var$useCategory(glyph) {
return $9b772791ccede8a5$var$trie.get(glyph.codePoints[0]);
}
class $9b772791ccede8a5$var$USEInfo {
constructor(category, syllableType, syllable){
this.category = category;
this.syllableType = syllableType;
this.syllable = syllable;
}
}
function $9b772791ccede8a5$var$setupSyllables(font, glyphs) {
let syllable = 0;
for (let [start, end, tags] of $9b772791ccede8a5$var$stateMachine.match(glyphs.map($9b772791ccede8a5$var$useCategory))){
++syllable;
// Create shaper info
for(let i = start; i <= end; i++)glyphs[i].shaperInfo = new $9b772791ccede8a5$var$USEInfo($9b772791ccede8a5$var$categories[$9b772791ccede8a5$var$useCategory(glyphs[i])], tags[0], syllable);
// Assign rphf feature
let limit = glyphs[start].shaperInfo.category === 'R' ? 1 : Math.min(3, end - start);
for(let i = start; i < start + limit; i++)glyphs[i].features.rphf = true;
}
}
function $9b772791ccede8a5$var$clearSubstitutionFlags(font, glyphs) {
for (let glyph of glyphs)glyph.substituted = false;
}
function $9b772791ccede8a5$var$recordRphf(font, glyphs) {
for (let glyph of glyphs)if (glyph.substituted && glyph.features.rphf) // Mark a substituted repha.
glyph.shaperInfo.category = 'R';
}
function $9b772791ccede8a5$var$recordPref(font, glyphs) {
for (let glyph of glyphs)if (glyph.substituted) // Mark a substituted pref as VPre, as they behave the same way.
glyph.shaperInfo.category = 'VPre';
}
function $9b772791ccede8a5$var$reorder(font, glyphs) {
let dottedCircle = font.glyphForCodePoint(0x25cc).id;
for(let start = 0, end = $9b772791ccede8a5$var$nextSyllable(glyphs, 0); start < glyphs.length; start = end, end = $9b772791ccede8a5$var$nextSyllable(glyphs, start)){
let i, j;
let info = glyphs[start].shaperInfo;
let type = info.syllableType;
// Only a few syllable types need reordering.
if (type !== 'virama_terminated_cluster' && type !== 'standard_cluster' && type !== 'broken_cluster') continue;
// Insert a dotted circle glyph in broken clusters.
if (type === 'broken_cluster' && dottedCircle) {
let g = new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(font, dottedCircle, [
0x25cc
]);
g.shaperInfo = info;
// Insert after possible Repha.
for(i = start; i < end && glyphs[i].shaperInfo.category === 'R'; i++);
glyphs.splice(++i, 0, g);
end++;
}
// Move things forward.
if (info.category === 'R' && end - start > 1) // Got a repha. Reorder it to after first base, before first halant.
for(i = start + 1; i < end; i++){
info = glyphs[i].shaperInfo;
if ($9b772791ccede8a5$var$isBase(info) || $9b772791ccede8a5$var$isHalant(glyphs[i])) {
// If we hit a halant, move before it; otherwise it's a base: move to it's
// place, and shift things in between backward.
if ($9b772791ccede8a5$var$isHalant(glyphs[i])) i--;
glyphs.splice(start, 0, ...glyphs.splice(start + 1, i - start), glyphs[i]);
break;
}
}
// Move things back.
for(i = start, j = end; i < end; i++){
info = glyphs[i].shaperInfo;
if ($9b772791ccede8a5$var$isBase(info) || $9b772791ccede8a5$var$isHalant(glyphs[i])) // If we hit a halant, move after it; otherwise it's a base: move to it's
// place, and shift things in between backward.
j = $9b772791ccede8a5$var$isHalant(glyphs[i]) ? i + 1 : i;
else if ((info.category === 'VPre' || info.category === 'VMPre') && j < i) glyphs.splice(j, 1, glyphs[i], ...glyphs.splice(j, i - j));
}
}
}
function $9b772791ccede8a5$var$nextSyllable(glyphs, start) {
if (start >= glyphs.length) return start;
let syllable = glyphs[start].shaperInfo.syllable;
while(++start < glyphs.length && glyphs[start].shaperInfo.syllable === syllable);
return start;
}
function $9b772791ccede8a5$var$isHalant(glyph) {
return glyph.shaperInfo.category === 'H' && !glyph.isLigated;
}
function $9b772791ccede8a5$var$isBase(info) {
return info.category === 'B' || info.category === 'GB';
}
const $fdb4471fc82bc2c2$var$SHAPERS = {
arab: (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
mong: (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
syrc: (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
'nko ': (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
phag: (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
mand: (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
mani: (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
phlp: (0, $17ba6019f27bfcf9$export$2e2bcd8739ae039),
hang: (0, $fa1d9fd80dd7279e$export$2e2bcd8739ae039),
bng2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
beng: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
dev2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
deva: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
gjr2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
gujr: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
guru: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
gur2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
knda: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
knd2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
mlm2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
mlym: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
ory2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
orya: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
taml: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
tml2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
telu: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
tel2: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
khmr: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
bali: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
batk: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
brah: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
bugi: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
buhd: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
cakm: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
cham: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
dupl: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
egyp: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
gran: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
hano: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
java: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
kthi: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
kali: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
khar: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
khoj: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
sind: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
lepc: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
limb: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
mahj: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
// mand: UniversalShaper, // Mandaic
// mani: UniversalShaper, // Manichaean
mtei: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
modi: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
// mong: UniversalShaper, // Mongolian
// 'nko ': UniversalShaper, // N’Ko
hmng: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
// phag: UniversalShaper, // Phags-pa
// phlp: UniversalShaper, // Psalter Pahlavi
rjng: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
saur: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
shrd: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
sidd: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
sinh: (0, $d203e6b9523d0071$export$2e2bcd8739ae039),
sund: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
sylo: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
tglg: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
tagb: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
tale: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
lana: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
tavt: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
takr: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
tibt: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
tfng: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
tirh: (0, $9b772791ccede8a5$export$2e2bcd8739ae039),
latn: (0, $d28fb665ee343afc$export$2e2bcd8739ae039),
DFLT: (0, $d28fb665ee343afc$export$2e2bcd8739ae039 // Default
)
};
function $fdb4471fc82bc2c2$export$7877a478dd30fd3d(script) {
if (!Array.isArray(script)) script = [
script
];
for (let s of script){
let shaper = $fdb4471fc82bc2c2$var$SHAPERS[s];
if (shaper) return shaper;
}
return 0, $d28fb665ee343afc$export$2e2bcd8739ae039;
}
class $86bc1883359e094a$export$2e2bcd8739ae039 extends (0, $7b226e6bbeadedeb$export$2e2bcd8739ae039) {
applyLookup(lookupType, table) {
switch(lookupType){
case 1:
{
let index = this.coverageIndex(table.coverage);
if (index === -1) return false;
let glyph = this.glyphIterator.cur;
switch(table.version){
case 1:
glyph.id = glyph.id + table.deltaGlyphID & 0xffff;
break;
case 2:
glyph.id = table.substitute.get(index);
break;
}
return true;
}
case 2:
{
let index = this.coverageIndex(table.coverage);
if (index !== -1) {
let sequence = table.sequences.get(index);
if (sequence.length === 0) {
// If the sequence length is zero, delete the glyph.
// The OpenType spec disallows this, but seems like Harfbuzz and Uniscribe allow it.
this.glyphs.splice(this.glyphIterator.index, 1);
return true;
}
this.glyphIterator.cur.id = sequence[0];
this.glyphIterator.cur.ligatureComponent = 0;
let features = this.glyphIterator.cur.features;
let curGlyph = this.glyphIterator.cur;
let replacement = sequence.slice(1).map((gid, i)=>{
let glyph = new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(this.font, gid, undefined, features);
glyph.shaperInfo = curGlyph.shaperInfo;
glyph.isLigated = curGlyph.isLigated;
glyph.ligatureComponent = i + 1;
glyph.substituted = true;
glyph.isMultiplied = true;
return glyph;
});
this.glyphs.splice(this.glyphIterator.index + 1, 0, ...replacement);
return true;
}
return false;
}
case 3:
{
let index = this.coverageIndex(table.coverage);
if (index !== -1) {
let USER_INDEX = 0; // TODO
this.glyphIterator.cur.id = table.alternateSet.get(index)[USER_INDEX];
return true;
}
return false;
}
case 4:
{
let index = this.coverageIndex(table.coverage);
if (index === -1) return false;
for (let ligature of table.ligatureSets.get(index)){
let matched = this.sequenceMatchIndices(1, ligature.components);
if (!matched) continue;
let curGlyph = this.glyphIterator.cur;
// Concatenate all of the characters the new ligature will represent
let characters = curGlyph.codePoints.slice();
for (let index of matched)characters.push(...this.glyphs[index].codePoints);
// Create the replacement ligature glyph
let ligatureGlyph = new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(this.font, ligature.glyph, characters, curGlyph.features);
ligatureGlyph.shaperInfo = curGlyph.shaperInfo;
ligatureGlyph.isLigated = true;
ligatureGlyph.substituted = true;
// From Harfbuzz:
// - If it *is* a mark ligature, we don't allocate a new ligature id, and leave
// the ligature to keep its old ligature id. This will allow it to attach to
// a base ligature in GPOS. Eg. if the sequence is: LAM,LAM,SHADDA,FATHA,HEH,
// and LAM,LAM,HEH for a ligature, they will leave SHADDA and FATHA with a
// ligature id and component value of 2. Then if SHADDA,FATHA form a ligature
// later, we don't want them to lose their ligature id/component, otherwise
// GPOS will fail to correctly position the mark ligature on top of the
// LAM,LAM,HEH ligature. See https://bugzilla.gnome.org/show_bug.cgi?id=676343
//
// - If a ligature is formed of components that some of which are also ligatures
// themselves, and those ligature components had marks attached to *their*
// components, we have to attach the marks to the new ligature component
// positions! Now *that*'s tricky! And these marks may be following the
// last component of the whole sequence, so we should loop forward looking
// for them and update them.
//
// Eg. the sequence is LAM,LAM,SHADDA,FATHA,HEH, and the font first forms a
// 'calt' ligature of LAM,HEH, leaving the SHADDA and FATHA with a ligature
// id and component == 1. Now, during 'liga', the LAM and the LAM-HEH ligature
// form a LAM-LAM-HEH ligature. We need to reassign the SHADDA and FATHA to
// the new ligature with a component value of 2.
//
// This in fact happened to a font... See https://bugzilla.gnome.org/show_bug.cgi?id=437633
let isMarkLigature = curGlyph.isMark;
for(let i = 0; i < matched.length && isMarkLigature; i++)isMarkLigature = this.glyphs[matched[i]].isMark;
ligatureGlyph.ligatureID = isMarkLigature ? null : this.ligatureID++;
let lastLigID = curGlyph.ligatureID;
let lastNumComps = curGlyph.codePoints.length;
let curComps = lastNumComps;
let idx = this.glyphIterator.index + 1;
// Set ligatureID and ligatureComponent on glyphs that were skipped in the matched sequence.
// This allows GPOS to attach marks to the correct ligature components.
for (let matchIndex of matched){
// Don't assign new ligature components for mark ligatures (see above)
if (isMarkLigature) idx = matchIndex;
else while(idx < matchIndex){
var ligatureComponent = curComps - lastNumComps + Math.min(this.glyphs[idx].ligatureComponent || 1, lastNumComps);
this.glyphs[idx].ligatureID = ligatureGlyph.ligatureID;
this.glyphs[idx].ligatureComponent = ligatureComponent;
idx++;
}
lastLigID = this.glyphs[idx].ligatureID;
lastNumComps = this.glyphs[idx].codePoints.length;
curComps += lastNumComps;
idx++; // skip base glyph
}
// Adjust ligature components for any marks following
if (lastLigID && !isMarkLigature) for(let i = idx; i < this.glyphs.length; i++){
if (this.glyphs[i].ligatureID === lastLigID) {
var ligatureComponent = curComps - lastNumComps + Math.min(this.glyphs[i].ligatureComponent || 1, lastNumComps);
this.glyphs[i].ligatureComponent = ligatureComponent;
} else break;
}
// Delete the matched glyphs, and replace the current glyph with the ligature glyph
for(let i = matched.length - 1; i >= 0; i--)this.glyphs.splice(matched[i], 1);
this.glyphs[this.glyphIterator.index] = ligatureGlyph;
return true;
}
return false;
}
case 5:
return this.applyContext(table);
case 6:
return this.applyChainingContext(table);
case 7:
return this.applyLookup(table.lookupType, table.extension);
default:
throw new Error(`GSUB lookupType ${lookupType} is not supported`);
}
}
}
class $79ea6270f0a90256$export$2e2bcd8739ae039 extends (0, $7b226e6bbeadedeb$export$2e2bcd8739ae039) {
applyPositionValue(sequenceIndex, value) {
let position = this.positions[this.glyphIterator.peekIndex(sequenceIndex)];
if (value.xAdvance != null) position.xAdvance += value.xAdvance;
if (value.yAdvance != null) position.yAdvance += value.yAdvance;
if (value.xPlacement != null) position.xOffset += value.xPlacement;
if (value.yPlacement != null) position.yOffset += value.yPlacement;
// Adjustments for font variations
let variationProcessor = this.font._variationProcessor;
let variationStore = this.font.GDEF && this.font.GDEF.itemVariationStore;
if (variationProcessor && variationStore) {
if (value.xPlaDevice) position.xOffset += variationProcessor.getDelta(variationStore, value.xPlaDevice.a, value.xPlaDevice.b);
if (value.yPlaDevice) position.yOffset += variationProcessor.getDelta(variationStore, value.yPlaDevice.a, value.yPlaDevice.b);
if (value.xAdvDevice) position.xAdvance += variationProcessor.getDelta(variationStore, value.xAdvDevice.a, value.xAdvDevice.b);
if (value.yAdvDevice) position.yAdvance += variationProcessor.getDelta(variationStore, value.yAdvDevice.a, value.yAdvDevice.b);
}
// TODO: device tables
}
applyLookup(lookupType, table) {
switch(lookupType){
case 1:
{
let index = this.coverageIndex(table.coverage);
if (index === -1) return false;
switch(table.version){
case 1:
this.applyPositionValue(0, table.value);
break;
case 2:
this.applyPositionValue(0, table.values.get(index));
break;
}
return true;
}
case 2:
{
let nextGlyph = this.glyphIterator.peek();
if (!nextGlyph) return false;
let index = this.coverageIndex(table.coverage);
if (index === -1) return false;
switch(table.version){
case 1:
let set = table.pairSets.get(index);
for (let pair of set)if (pair.secondGlyph === nextGlyph.id) {
this.applyPositionValue(0, pair.value1);
this.applyPositionValue(1, pair.value2);
return true;
}
return false;
case 2:
let class1 = this.getClassID(this.glyphIterator.cur.id, table.classDef1);
let class2 = this.getClassID(nextGlyph.id, table.classDef2);
if (class1 === -1 || class2 === -1) return false;
var pair = table.classRecords.get(class1).get(class2);
this.applyPositionValue(0, pair.value1);
this.applyPositionValue(1, pair.value2);
return true;
}
}
case 3:
{
let nextIndex = this.glyphIterator.peekIndex();
let nextGlyph = this.glyphs[nextIndex];
if (!nextGlyph) return false;
let curRecord = table.entryExitRecords[this.coverageIndex(table.coverage)];
if (!curRecord || !curRecord.exitAnchor) return false;
let nextRecord = table.entryExitRecords[this.coverageIndex(table.coverage, nextGlyph.id)];
if (!nextRecord || !nextRecord.entryAnchor) return false;
let entry = this.getAnchor(nextRecord.entryAnchor);
let exit = this.getAnchor(curRecord.exitAnchor);
let cur = this.positions[this.glyphIterator.index];
let next = this.positions[nextIndex];
let d;
switch(this.direction){
case 'ltr':
cur.xAdvance = exit.x + cur.xOffset;
d = entry.x + next.xOffset;
next.xAdvance -= d;
next.xOffset -= d;
break;
case 'rtl':
d = exit.x + cur.xOffset;
cur.xAdvance -= d;
cur.xOffset -= d;
next.xAdvance = entry.x + next.xOffset;
break;
}
if (this.glyphIterator.flags.rightToLeft) {
this.glyphIterator.cur.cursiveAttachment = nextIndex;
cur.yOffset = entry.y - exit.y;
} else {
nextGlyph.cursiveAttachment = this.glyphIterator.index;
cur.yOffset = exit.y - entry.y;
}
return true;
}
case 4:
{
let markIndex = this.coverageIndex(table.markCoverage);
if (markIndex === -1) return false;
// search backward for a base glyph
let baseGlyphIndex = this.glyphIterator.index;
while(--baseGlyphIndex >= 0 && (this.glyphs[baseGlyphIndex].isMark || this.glyphs[baseGlyphIndex].ligatureComponent > 0));
if (baseGlyphIndex < 0) return false;
let baseIndex = this.coverageIndex(table.baseCoverage, this.glyphs[baseGlyphIndex].id);
if (baseIndex === -1) return false;
let markRecord = table.markArray[markIndex];
let baseAnchor = table.baseArray[baseIndex][markRecord.class];
this.applyAnchor(markRecord, baseAnchor, baseGlyphIndex);
return true;
}
case 5:
{
let markIndex = this.coverageIndex(table.markCoverage);
if (markIndex === -1) return false;
// search backward for a base glyph
let baseGlyphIndex = this.glyphIterator.index;
while(--baseGlyphIndex >= 0 && this.glyphs[baseGlyphIndex].isMark);
if (baseGlyphIndex < 0) return false;
let ligIndex = this.coverageIndex(table.ligatureCoverage, this.glyphs[baseGlyphIndex].id);
if (ligIndex === -1) return false;
let ligAttach = table.ligatureArray[ligIndex];
let markGlyph = this.glyphIterator.cur;
let ligGlyph = this.glyphs[baseGlyphIndex];
let compIndex = ligGlyph.ligatureID && ligGlyph.ligatureID === markGlyph.ligatureID && markGlyph.ligatureComponent > 0 ? Math.min(markGlyph.ligatureComponent, ligGlyph.codePoints.length) - 1 : ligGlyph.codePoints.length - 1;
let markRecord = table.markArray[markIndex];
let baseAnchor = ligAttach[compIndex][markRecord.class];
this.applyAnchor(markRecord, baseAnchor, baseGlyphIndex);
return true;
}
case 6:
{
let mark1Index = this.coverageIndex(table.mark1Coverage);
if (mark1Index === -1) return false;
// get the previous mark to attach to
let prevIndex = this.glyphIterator.peekIndex(-1);
let prev = this.glyphs[prevIndex];
if (!prev || !prev.isMark) return false;
let cur = this.glyphIterator.cur;
// The following logic was borrowed from Harfbuzz
let good = false;
if (cur.ligatureID === prev.ligatureID) {
if (!cur.ligatureID) good = true;
else if (cur.ligatureComponent === prev.ligatureComponent) good = true;
} else // If ligature ids don't match, it may be the case that one of the marks
// itself is a ligature, in which case match.
if (cur.ligatureID && !cur.ligatureComponent || prev.ligatureID && !prev.ligatureComponent) good = true;
if (!good) return false;
let mark2Index = this.coverageIndex(table.mark2Coverage, prev.id);
if (mark2Index === -1) return false;
let markRecord = table.mark1Array[mark1Index];
let baseAnchor = table.mark2Array[mark2Index][markRecord.class];
this.applyAnchor(markRecord, baseAnchor, prevIndex);
return true;
}
case 7:
return this.applyContext(table);
case 8:
return this.applyChainingContext(table);
case 9:
return this.applyLookup(table.lookupType, table.extension);
default:
throw new Error(`Unsupported GPOS table: ${lookupType}`);
}
}
applyAnchor(markRecord, baseAnchor, baseGlyphIndex) {
let baseCoords = this.getAnchor(baseAnchor);
let markCoords = this.getAnchor(markRecord.markAnchor);
let basePos = this.positions[baseGlyphIndex];
let markPos = this.positions[this.glyphIterator.index];
markPos.xOffset = baseCoords.x - markCoords.x;
markPos.yOffset = baseCoords.y - markCoords.y;
this.glyphIterator.cur.markAttachment = baseGlyphIndex;
}
getAnchor(anchor) {
// TODO: contour point, device tables
let x = anchor.xCoordinate;
let y = anchor.yCoordinate;
// Adjustments for font variations
let variationProcessor = this.font._variationProcessor;
let variationStore = this.font.GDEF && this.font.GDEF.itemVariationStore;
if (variationProcessor && variationStore) {
if (anchor.xDeviceTable) x += variationProcessor.getDelta(variationStore, anchor.xDeviceTable.a, anchor.xDeviceTable.b);
if (anchor.yDeviceTable) y += variationProcessor.getDelta(variationStore, anchor.yDeviceTable.a, anchor.yDeviceTable.b);
}
return {
x: x,
y: y
};
}
applyFeatures(userFeatures, glyphs, advances) {
super.applyFeatures(userFeatures, glyphs, advances);
for(var i = 0; i < this.glyphs.length; i++)this.fixCursiveAttachment(i);
this.fixMarkAttachment();
}
fixCursiveAttachment(i) {
let glyph = this.glyphs[i];
if (glyph.cursiveAttachment != null) {
let j = glyph.cursiveAttachment;
glyph.cursiveAttachment = null;
this.fixCursiveAttachment(j);
this.positions[i].yOffset += this.positions[j].yOffset;
}
}
fixMarkAttachment() {
for(let i = 0; i < this.glyphs.length; i++){
let glyph = this.glyphs[i];
if (glyph.markAttachment != null) {
let j = glyph.markAttachment;
this.positions[i].xOffset += this.positions[j].xOffset;
this.positions[i].yOffset += this.positions[j].yOffset;
if (this.direction === 'ltr') for(let k = j; k < i; k++){
this.positions[i].xOffset -= this.positions[k].xAdvance;
this.positions[i].yOffset -= this.positions[k].yAdvance;
}
else for(let k = j + 1; k < i + 1; k++){
this.positions[i].xOffset += this.positions[k].xAdvance;
this.positions[i].yOffset += this.positions[k].yAdvance;
}
}
}
}
}
class $b2f26a32cb9ab2fa$export$2e2bcd8739ae039 {
setup(glyphRun) {
// Map glyphs to GlyphInfo objects so data can be passed between
// GSUB and GPOS without mutating the real (shared) Glyph objects.
this.glyphInfos = glyphRun.glyphs.map((glyph)=>new (0, $f22bb23c9fd478d8$export$2e2bcd8739ae039)(this.font, glyph.id, [
...glyph.codePoints
]));
// Select a script based on what is available in GSUB/GPOS.
let script = null;
if (this.GPOSProcessor) script = this.GPOSProcessor.selectScript(glyphRun.script, glyphRun.language, glyphRun.direction);
if (this.GSUBProcessor) script = this.GSUBProcessor.selectScript(glyphRun.script, glyphRun.language, glyphRun.direction);
// Choose a shaper based on the script, and setup a shaping plan.
// This determines which features to apply to which glyphs.
this.shaper = $fdb4471fc82bc2c2$export$7877a478dd30fd3d(script);
this.plan = new (0, $d7e93cca3cf8ce8a$export$2e2bcd8739ae039)(this.font, script, glyphRun.direction);
this.shaper.plan(this.plan, this.glyphInfos, glyphRun.features);
// Assign chosen features to output glyph run
for(let key in this.plan.allFeatures)glyphRun.features[key] = true;
}
substitute(glyphRun) {
if (this.GSUBProcessor) {
this.plan.process(this.GSUBProcessor, this.glyphInfos);
// Map glyph infos back to normal Glyph objects
glyphRun.glyphs = this.glyphInfos.map((glyphInfo)=>this.font.getGlyph(glyphInfo.id, glyphInfo.codePoints));
}
}
position(glyphRun) {
if (this.shaper.zeroMarkWidths === 'BEFORE_GPOS') this.zeroMarkAdvances(glyphRun.positions);
if (this.GPOSProcessor) this.plan.process(this.GPOSProcessor, this.glyphInfos, glyphRun.positions);
if (this.shaper.zeroMarkWidths === 'AFTER_GPOS') this.zeroMarkAdvances(glyphRun.positions);
// Reverse the glyphs and positions if the script is right-to-left
if (glyphRun.direction === 'rtl') {
glyphRun.glyphs.reverse();
glyphRun.positions.reverse();
}
return this.GPOSProcessor && this.GPOSProcessor.features;
}
zeroMarkAdvances(positions) {
for(let i = 0; i < this.glyphInfos.length; i++)if (this.glyphInfos[i].isMark) {
positions[i].xAdvance = 0;
positions[i].yAdvance = 0;
}
}
cleanup() {
this.glyphInfos = null;
this.plan = null;
this.shaper = null;
}
getAvailableFeatures(script, language) {
let features = [];
if (this.GSUBProcessor) {
this.GSUBProcessor.selectScript(script, language);
features.push(...Object.keys(this.GSUBProcessor.features));
}
if (this.GPOSProcessor) {
this.GPOSProcessor.selectScript(script, language);
features.push(...Object.keys(this.GPOSProcessor.features));
}
return features;
}
constructor(font){
this.font = font;
this.glyphInfos = null;
this.plan = null;
this.GSUBProcessor = null;
this.GPOSProcessor = null;
this.fallbackPosition = true;
if (font.GSUB) this.GSUBProcessor = new (0, $86bc1883359e094a$export$2e2bcd8739ae039)(font, font.GSUB);
if (font.GPOS) this.GPOSProcessor = new (0, $79ea6270f0a90256$export$2e2bcd8739ae039)(font, font.GPOS);
}
}
class $9d641258c9d7180d$export$2e2bcd8739ae039 {
layout(string, features, script, language, direction) {
// Make the features parameter optional
if (typeof features === 'string') {
direction = language;
language = script;
script = features;
features = [];
}
// Map string to glyphs if needed
if (typeof string === 'string') {
// Attempt to detect the script from the string if not provided.
if (script == null) script = $e38a1a895f6aeb54$export$e5cb25e204fb8450(string);
var glyphs = this.font.glyphsForString(string);
} else {
// Attempt to detect the script from the glyph code points if not provided.
if (script == null) {
let codePoints = [];
for (let glyph of string)codePoints.push(...glyph.codePoints);
script = $e38a1a895f6aeb54$export$16fab0757cfc223d(codePoints);
}
var glyphs = string;
}
let glyphRun = new (0, $b19c79ec7a94fa39$export$2e2bcd8739ae039)(glyphs, features, script, language, direction);
// Return early if there are no glyphs
if (glyphs.length === 0) {
glyphRun.positions = [];
return glyphRun;
}
// Setup the advanced layout engine
if (this.engine && this.engine.setup) this.engine.setup(glyphRun);
// Substitute and position the glyphs
this.substitute(glyphRun);
this.position(glyphRun);
this.hideDefaultIgnorables(glyphRun.glyphs, glyphRun.positions);
// Let the layout engine clean up any state it might have
if (this.engine && this.engine.cleanup) this.engine.cleanup();
return glyphRun;
}
substitute(glyphRun) {
// Call the advanced layout engine to make substitutions
if (this.engine && this.engine.substitute) this.engine.substitute(glyphRun);
}
position(glyphRun) {
// Get initial glyph positions
glyphRun.positions = glyphRun.glyphs.map((glyph)=>new (0, $9195cf1266c12ea5$export$2e2bcd8739ae039)(glyph.advanceWidth));
let positioned = null;
// Call the advanced layout engine. Returns the features applied.
if (this.engine && this.engine.position) positioned = this.engine.position(glyphRun);
// if there is no GPOS table, use unicode properties to position marks.
if (!positioned && (!this.engine || this.engine.fallbackPosition)) {
if (!this.unicodeLayoutEngine) this.unicodeLayoutEngine = new (0, $a57a26817cd35108$export$2e2bcd8739ae039)(this.font);
this.unicodeLayoutEngine.positionGlyphs(glyphRun.glyphs, glyphRun.positions);
}
// if kerning is not supported by GPOS, do kerning with the TrueType/AAT kern table
if ((!positioned || !positioned.kern) && glyphRun.features.kern !== false && this.font.kern) {
if (!this.kernProcessor) this.kernProcessor = new (0, $4646d52c2a559cdb$export$2e2bcd8739ae039)(this.font);
this.kernProcessor.process(glyphRun.glyphs, glyphRun.positions);
glyphRun.features.kern = true;
}
}
hideDefaultIgnorables(glyphs, positions) {
let space = this.font.glyphForCodePoint(0x20);
for(let i = 0; i < glyphs.length; i++)if (this.isDefaultIgnorable(glyphs[i].codePoints[0])) {
glyphs[i] = space;
positions[i].xAdvance = 0;
positions[i].yAdvance = 0;
}
}
isDefaultIgnorable(ch) {
// From DerivedCoreProperties.txt in the Unicode database,
// minus U+115F, U+1160, U+3164 and U+FFA0, which is what
// Harfbuzz and Uniscribe do.
let plane = ch >> 16;
if (plane === 0) // BMP
switch(ch >> 8){
case 0x00:
return ch === 0x00AD;
case 0x03:
return ch === 0x034F;
case 0x06:
return ch === 0x061C;
case 0x17:
return 0x17B4 <= ch && ch <= 0x17B5;
case 0x18:
return 0x180B <= ch && ch <= 0x180E;
case 0x20:
return 0x200B <= ch && ch <= 0x200F || 0x202A <= ch && ch <= 0x202E || 0x2060 <= ch && ch <= 0x206F;
case 0xFE:
return 0xFE00 <= ch && ch <= 0xFE0F || ch === 0xFEFF;
case 0xFF:
return 0xFFF0 <= ch && ch <= 0xFFF8;
default:
return false;
}
else // Other planes
switch(plane){
case 0x01:
return 0x1BCA0 <= ch && ch <= 0x1BCA3 || 0x1D173 <= ch && ch <= 0x1D17A;
case 0x0E:
return 0xE0000 <= ch && ch <= 0xE0FFF;
default:
return false;
}
}
getAvailableFeatures(script, language) {
let features = [];
if (this.engine) features.push(...this.engine.getAvailableFeatures(script, language));
if (this.font.kern && features.indexOf('kern') === -1) features.push('kern');
return features;
}
stringsForGlyph(gid) {
let result = new Set;
let codePoints = this.font._cmapProcessor.codePointsForGlyph(gid);
for (let codePoint of codePoints)result.add(String.fromCodePoint(codePoint));
if (this.engine && this.engine.stringsForGlyph) for (let string of this.engine.stringsForGlyph(gid))result.add(string);
return Array.from(result);
}
constructor(font){
this.font = font;
this.unicodeLayoutEngine = null;
this.kernProcessor = null;
// Choose an advanced layout engine. We try the AAT morx table first since more
// scripts are currently supported because the shaping logic is built into the font.
if (this.font.morx) this.engine = new (0, $860fcbd64bc12fbc$export$2e2bcd8739ae039)(this.font);
else if (this.font.GSUB || this.font.GPOS) this.engine = new (0, $b2f26a32cb9ab2fa$export$2e2bcd8739ae039)(this.font);
}
}
const $67ee4828d81adb28$var$SVG_COMMANDS = {
moveTo: 'M',
lineTo: 'L',
quadraticCurveTo: 'Q',
bezierCurveTo: 'C',
closePath: 'Z'
};
class $67ee4828d81adb28$export$2e2bcd8739ae039 {
/**
* Compiles the path to a JavaScript function that can be applied with
* a graphics context in order to render the path.
* @return {string}
*/ toFunction() {
return (ctx)=>{
this.commands.forEach((c)=>{
return ctx[c.command].apply(ctx, c.args);
});
};
}
/**
* Converts the path to an SVG path data string
* @return {string}
*/ toSVG() {
let cmds = this.commands.map((c)=>{
let args = c.args.map((arg)=>Math.round(arg * 100) / 100);
return `${$67ee4828d81adb28$var$SVG_COMMANDS[c.command]}${args.join(' ')}`;
});
return cmds.join('');
}
/**
* Gets the "control box" of a path.
* This is like the bounding box, but it includes all points including
* control points of bezier segments and is much faster to compute than
* the real bounding box.
* @type {BBox}
*/ get cbox() {
if (!this._cbox) {
let cbox = new (0, $0e2da1c4ce69e8ad$export$2e2bcd8739ae039);
for (let command of this.commands)for(let i = 0; i < command.args.length; i += 2)cbox.addPoint(command.args[i], command.args[i + 1]);
this._cbox = Object.freeze(cbox);
}
return this._cbox;
}
/**
* Gets the exact bounding box of the path by evaluating curve segments.
* Slower to compute than the control box, but more accurate.
* @type {BBox}
*/ get bbox() {
if (this._bbox) return this._bbox;
let bbox = new (0, $0e2da1c4ce69e8ad$export$2e2bcd8739ae039);
let cx = 0, cy = 0;
let f = (t)=>Math.pow(1 - t, 3) * p0[i] + 3 * Math.pow(1 - t, 2) * t * p1[i] + 3 * (1 - t) * Math.pow(t, 2) * p2[i] + Math.pow(t, 3) * p3[i];
for (let c of this.commands)switch(c.command){
case 'moveTo':
case 'lineTo':
let [x, y] = c.args;
bbox.addPoint(x, y);
cx = x;
cy = y;
break;
case 'quadraticCurveTo':
case 'bezierCurveTo':
if (c.command === 'quadraticCurveTo') {
// http://fontforge.org/bezier.html
var [qp1x, qp1y, p3x, p3y] = c.args;
var cp1x = cx + 2 / 3 * (qp1x - cx); // CP1 = QP0 + 2/3 * (QP1-QP0)
var cp1y = cy + 2 / 3 * (qp1y - cy);
var cp2x = p3x + 2 / 3 * (qp1x - p3x); // CP2 = QP2 + 2/3 * (QP1-QP2)
var cp2y = p3y + 2 / 3 * (qp1y - p3y);
} else var [cp1x, cp1y, cp2x, cp2y, p3x, p3y] = c.args;
// http://blog.hackers-cafe.net/2009/06/how-to-calculate-bezier-curves-bounding.html
bbox.addPoint(p3x, p3y);
var p0 = [
cx,
cy
];
var p1 = [
cp1x,
cp1y
];
var p2 = [
cp2x,
cp2y
];
var p3 = [
p3x,
p3y
];
for(var i = 0; i <= 1; i++){
let b = 6 * p0[i] - 12 * p1[i] + 6 * p2[i];
let a = -3 * p0[i] + 9 * p1[i] - 9 * p2[i] + 3 * p3[i];
c = 3 * p1[i] - 3 * p0[i];
if (a === 0) {
if (b === 0) continue;
let t = -c / b;
if (0 < t && t < 1) {
if (i === 0) bbox.addPoint(f(t), bbox.maxY);
else if (i === 1) bbox.addPoint(bbox.maxX, f(t));
}
continue;
}
let b2ac = Math.pow(b, 2) - 4 * c * a;
if (b2ac < 0) continue;
let t1 = (-b + Math.sqrt(b2ac)) / (2 * a);
if (0 < t1 && t1 < 1) {
if (i === 0) bbox.addPoint(f(t1), bbox.maxY);
else if (i === 1) bbox.addPoint(bbox.maxX, f(t1));
}
let t2 = (-b - Math.sqrt(b2ac)) / (2 * a);
if (0 < t2 && t2 < 1) {
if (i === 0) bbox.addPoint(f(t2), bbox.maxY);
else if (i === 1) bbox.addPoint(bbox.maxX, f(t2));
}
}
cx = p3x;
cy = p3y;
break;
}
return this._bbox = Object.freeze(bbox);
}
/**
* Applies a mapping function to each point in the path.
* @param {function} fn
* @return {Path}
*/ mapPoints(fn) {
let path = new $67ee4828d81adb28$export$2e2bcd8739ae039;
for (let c of this.commands){
let args = [];
for(let i = 0; i < c.args.length; i += 2){
let [x, y] = fn(c.args[i], c.args[i + 1]);
args.push(x, y);
}
path[c.command](...args);
}
return path;
}
/**
* Transforms the path by the given matrix.
*/ transform(m0, m1, m2, m3, m4, m5) {
return this.mapPoints((x, y)=>{
const tx = m0 * x + m2 * y + m4;
const ty = m1 * x + m3 * y + m5;
return [
tx,
ty
];
});
}
/**
* Translates the path by the given offset.
*/ translate(x, y) {
return this.transform(1, 0, 0, 1, x, y);
}
/**
* Rotates the path by the given angle (in radians).
*/ rotate(angle) {
let cos = Math.cos(angle);
let sin = Math.sin(angle);
return this.transform(cos, sin, -sin, cos, 0, 0);
}
/**
* Scales the path.
*/ scale(scaleX, scaleY = scaleX) {
return this.transform(scaleX, 0, 0, scaleY, 0, 0);
}
constructor(){
this.commands = [];
this._bbox = null;
this._cbox = null;
}
}
for (let command of [
'moveTo',
'lineTo',
'quadraticCurveTo',
'bezierCurveTo',
'closePath'
])$67ee4828d81adb28$export$2e2bcd8739ae039.prototype[command] = function(...args) {
this._bbox = this._cbox = null;
this.commands.push({
command: command,
args: args
});
return this;
};
var $85e16e40023cfb0f$export$2e2bcd8739ae039 = [
'.notdef',
'.null',
'nonmarkingreturn',
'space',
'exclam',
'quotedbl',
'numbersign',
'dollar',
'percent',
'ampersand',
'quotesingle',
'parenleft',
'parenright',
'asterisk',
'plus',
'comma',
'hyphen',
'period',
'slash',
'zero',
'one',
'two',
'three',
'four',
'five',
'six',
'seven',
'eight',
'nine',
'colon',
'semicolon',
'less',
'equal',
'greater',
'question',
'at',
'A',
'B',
'C',
'D',
'E',
'F',
'G',
'H',
'I',
'J',
'K',
'L',
'M',
'N',
'O',
'P',
'Q',
'R',
'S',
'T',
'U',
'V',
'W',
'X',
'Y',
'Z',
'bracketleft',
'backslash',
'bracketright',
'asciicircum',
'underscore',
'grave',
'a',
'b',
'c',
'd',
'e',
'f',
'g',
'h',
'i',
'j',
'k',
'l',
'm',
'n',
'o',
'p',
'q',
'r',
's',
't',
'u',
'v',
'w',
'x',
'y',
'z',
'braceleft',
'bar',
'braceright',
'asciitilde',
'Adieresis',
'Aring',
'Ccedilla',
'Eacute',
'Ntilde',
'Odieresis',
'Udieresis',
'aacute',
'agrave',
'acircumflex',
'adieresis',
'atilde',
'aring',
'ccedilla',
'eacute',
'egrave',
'ecircumflex',
'edieresis',
'iacute',
'igrave',
'icircumflex',
'idieresis',
'ntilde',
'oacute',
'ograve',
'ocircumflex',
'odieresis',
'otilde',
'uacute',
'ugrave',
'ucircumflex',
'udieresis',
'dagger',
'degree',
'cent',
'sterling',
'section',
'bullet',
'paragraph',
'germandbls',
'registered',
'copyright',
'trademark',
'acute',
'dieresis',
'notequal',
'AE',
'Oslash',
'infinity',
'plusminus',
'lessequal',
'greaterequal',
'yen',
'mu',
'partialdiff',
'summation',
'product',
'pi',
'integral',
'ordfeminine',
'ordmasculine',
'Omega',
'ae',
'oslash',
'questiondown',
'exclamdown',
'logicalnot',
'radical',
'florin',
'approxequal',
'Delta',
'guillemotleft',
'guillemotright',
'ellipsis',
'nonbreakingspace',
'Agrave',
'Atilde',
'Otilde',
'OE',
'oe',
'endash',
'emdash',
'quotedblleft',
'quotedblright',
'quoteleft',
'quoteright',
'divide',
'lozenge',
'ydieresis',
'Ydieresis',
'fraction',
'currency',
'guilsinglleft',
'guilsinglright',
'fi',
'fl',
'daggerdbl',
'periodcentered',
'quotesinglbase',
'quotedblbase',
'perthousand',
'Acircumflex',
'Ecircumflex',
'Aacute',
'Edieresis',
'Egrave',
'Iacute',
'Icircumflex',
'Idieresis',
'Igrave',
'Oacute',
'Ocircumflex',
'apple',
'Ograve',
'Uacute',
'Ucircumflex',
'Ugrave',
'dotlessi',
'circumflex',
'tilde',
'macron',
'breve',
'dotaccent',
'ring',
'cedilla',
'hungarumlaut',
'ogonek',
'caron',
'Lslash',
'lslash',
'Scaron',
'scaron',
'Zcaron',
'zcaron',
'brokenbar',
'Eth',
'eth',
'Yacute',
'yacute',
'Thorn',
'thorn',
'minus',
'multiply',
'onesuperior',
'twosuperior',
'threesuperior',
'onehalf',
'onequarter',
'threequarters',
'franc',
'Gbreve',
'gbreve',
'Idotaccent',
'Scedilla',
'scedilla',
'Cacute',
'cacute',
'Ccaron',
'ccaron',
'dcroat'
];
class $0e4f52d7996e478b$export$2e2bcd8739ae039 {
_getPath() {
return new (0, $67ee4828d81adb28$export$2e2bcd8739ae039)();
}
_getCBox() {
return this.path.cbox;
}
_getBBox() {
return this.path.bbox;
}
_getTableMetrics(table) {
if (this.id < table.metrics.length) return table.metrics.get(this.id);
let metric = table.metrics.get(table.metrics.length - 1);
let res = {
advance: metric ? metric.advance : 0,
bearing: table.bearings.get(this.id - table.metrics.length) || 0
};
return res;
}
_getMetrics(cbox) {
if (this._metrics) return this._metrics;
let { advance: advanceWidth, bearing: leftBearing } = this._getTableMetrics(this._font.hmtx);
// For vertical metrics, use vmtx if available, or fall back to global data from OS/2 or hhea
if (this._font.vmtx) var { advance: advanceHeight, bearing: topBearing } = this._getTableMetrics(this._font.vmtx);
else {
let os2;
if (typeof cbox === 'undefined' || cbox === null) ({ cbox: cbox } = this);
if ((os2 = this._font['OS/2']) && os2.version > 0) {
var advanceHeight = Math.abs(os2.typoAscender - os2.typoDescender);
var topBearing = os2.typoAscender - cbox.maxY;
} else {
let { hhea: hhea } = this._font;
var advanceHeight = Math.abs(hhea.ascent - hhea.descent);
var topBearing = hhea.ascent - cbox.maxY;
}
}
if (this._font._variationProcessor && this._font.HVAR) advanceWidth += this._font._variationProcessor.getAdvanceAdjustment(this.id, this._font.HVAR);
return this._metrics = {
advanceWidth: advanceWidth,
advanceHeight: advanceHeight,
leftBearing: leftBearing,
topBearing: topBearing
};
}
/**
* The glyph’s control box.
* This is often the same as the bounding box, but is faster to compute.
* Because of the way bezier curves are defined, some of the control points
* can be outside of the bounding box. Where `bbox` takes this into account,
* `cbox` does not. Thus, cbox is less accurate, but faster to compute.
* See [here](http://www.freetype.org/freetype2/docs/glyphs/glyphs-6.html#section-2)
* for a more detailed description.
*
* @type {BBox}
*/ get cbox() {
return this._getCBox();
}
/**
* The glyph’s bounding box, i.e. the rectangle that encloses the
* glyph outline as tightly as possible.
* @type {BBox}
*/ get bbox() {
return this._getBBox();
}
/**
* A vector Path object representing the glyph outline.
* @type {Path}
*/ get path() {
// Cache the path so we only decode it once
// Decoding is actually performed by subclasses
return this._getPath();
}
/**
* Returns a path scaled to the given font size.
* @param {number} size
* @return {Path}
*/ getScaledPath(size) {
let scale = 1 / this._font.unitsPerEm * size;
return this.path.scale(scale);
}
/**
* The glyph's advance width.
* @type {number}
*/ get advanceWidth() {
return this._getMetrics().advanceWidth;
}
/**
* The glyph's advance height.
* @type {number}
*/ get advanceHeight() {
return this._getMetrics().advanceHeight;
}
get ligatureCaretPositions() {}
_getName() {
let { post: post } = this._font;
if (!post) return null;
switch(post.version){
case 1:
return (0, $85e16e40023cfb0f$export$2e2bcd8739ae039)[this.id];
case 2:
let id = post.glyphNameIndex[this.id];
if (id < (0, $85e16e40023cfb0f$export$2e2bcd8739ae039).length) return (0, $85e16e40023cfb0f$export$2e2bcd8739ae039)[id];
return post.names[id - (0, $85e16e40023cfb0f$export$2e2bcd8739ae039).length];
case 2.5:
return (0, $85e16e40023cfb0f$export$2e2bcd8739ae039)[this.id + post.offsets[this.id]];
case 4:
return String.fromCharCode(post.map[this.id]);
}
}
/**
* The glyph's name
* @type {string}
*/ get name() {
return this._getName();
}
/**
* Renders the glyph to the given graphics context, at the specified font size.
* @param {CanvasRenderingContext2d} ctx
* @param {number} size
*/ render(ctx, size) {
ctx.save();
let scale = 1 / this._font.head.unitsPerEm * size;
ctx.scale(scale, scale);
let fn = this.path.toFunction();
fn(ctx);
ctx.fill();
ctx.restore();
}
constructor(id, codePoints, font){
/**
* The glyph id in the font
* @type {number}
*/ this.id = id;
/**
* An array of unicode code points that are represented by this glyph.
* There can be multiple code points in the case of ligatures and other glyphs
* that represent multiple visual characters.
* @type {number[]}
*/ this.codePoints = codePoints;
this._font = font;
// TODO: get this info from GDEF if available
this.isMark = this.codePoints.length > 0 && this.codePoints.every((0, $gfJaN$unicodeproperties.isMark));
this.isLigature = this.codePoints.length > 1;
}
}
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0e4f52d7996e478b$export$2e2bcd8739ae039.prototype, "cbox", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0e4f52d7996e478b$export$2e2bcd8739ae039.prototype, "bbox", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0e4f52d7996e478b$export$2e2bcd8739ae039.prototype, "path", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0e4f52d7996e478b$export$2e2bcd8739ae039.prototype, "advanceWidth", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0e4f52d7996e478b$export$2e2bcd8739ae039.prototype, "advanceHeight", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0e4f52d7996e478b$export$2e2bcd8739ae039.prototype, "name", null);
// The header for both simple and composite glyphs
let $f680320fa07ef53d$var$GlyfHeader = new $gfJaN$restructure.Struct({
numberOfContours: $gfJaN$restructure.int16,
xMin: $gfJaN$restructure.int16,
yMin: $gfJaN$restructure.int16,
xMax: $gfJaN$restructure.int16,
yMax: $gfJaN$restructure.int16
});
// Flags for simple glyphs
const $f680320fa07ef53d$var$ON_CURVE = 1;
const $f680320fa07ef53d$var$X_SHORT_VECTOR = 2;
const $f680320fa07ef53d$var$Y_SHORT_VECTOR = 4;
const $f680320fa07ef53d$var$REPEAT = 8;
const $f680320fa07ef53d$var$SAME_X = 16;
const $f680320fa07ef53d$var$SAME_Y = 32;
// Flags for composite glyphs
const $f680320fa07ef53d$var$ARG_1_AND_2_ARE_WORDS = 1;
const $f680320fa07ef53d$var$ARGS_ARE_XY_VALUES = 2;
const $f680320fa07ef53d$var$ROUND_XY_TO_GRID = 4;
const $f680320fa07ef53d$var$WE_HAVE_A_SCALE = 8;
const $f680320fa07ef53d$var$MORE_COMPONENTS = 32;
const $f680320fa07ef53d$var$WE_HAVE_AN_X_AND_Y_SCALE = 64;
const $f680320fa07ef53d$var$WE_HAVE_A_TWO_BY_TWO = 128;
const $f680320fa07ef53d$var$WE_HAVE_INSTRUCTIONS = 256;
const $f680320fa07ef53d$var$USE_MY_METRICS = 512;
const $f680320fa07ef53d$var$OVERLAP_COMPOUND = 1024;
const $f680320fa07ef53d$var$SCALED_COMPONENT_OFFSET = 2048;
const $f680320fa07ef53d$var$UNSCALED_COMPONENT_OFFSET = 4096;
class $f680320fa07ef53d$export$baf26146a414f24a {
copy() {
return new $f680320fa07ef53d$export$baf26146a414f24a(this.onCurve, this.endContour, this.x, this.y);
}
constructor(onCurve, endContour, x = 0, y = 0){
this.onCurve = onCurve;
this.endContour = endContour;
this.x = x;
this.y = y;
}
}
// Represents a component in a composite glyph
class $f680320fa07ef53d$var$Component {
constructor(glyphID, dx, dy){
this.glyphID = glyphID;
this.dx = dx;
this.dy = dy;
this.pos = 0;
this.scaleX = this.scaleY = 1;
this.scale01 = this.scale10 = 0;
}
}
class $f680320fa07ef53d$export$2e2bcd8739ae039 extends (0, $0e4f52d7996e478b$export$2e2bcd8739ae039) {
// Parses just the glyph header and returns the bounding box
_getCBox(internal) {
// We need to decode the glyph if variation processing is requested,
// so it's easier just to recompute the path's cbox after decoding.
if (this._font._variationProcessor && !internal) return this.path.cbox;
let stream = this._font._getTableStream('glyf');
stream.pos += this._font.loca.offsets[this.id];
let glyph = $f680320fa07ef53d$var$GlyfHeader.decode(stream);
let cbox = new (0, $0e2da1c4ce69e8ad$export$2e2bcd8739ae039)(glyph.xMin, glyph.yMin, glyph.xMax, glyph.yMax);
return Object.freeze(cbox);
}
// Parses a single glyph coordinate
_parseGlyphCoord(stream, prev, short, same) {
if (short) {
var val = stream.readUInt8();
if (!same) val = -val;
val += prev;
} else if (same) var val = prev;
else var val = prev + stream.readInt16BE();
return val;
}
// Decodes the glyph data into points for simple glyphs,
// or components for composite glyphs
_decode() {
let glyfPos = this._font.loca.offsets[this.id];
let nextPos = this._font.loca.offsets[this.id + 1];
// Nothing to do if there is no data for this glyph
if (glyfPos === nextPos) return null;
let stream = this._font._getTableStream('glyf');
stream.pos += glyfPos;
let startPos = stream.pos;
let glyph = $f680320fa07ef53d$var$GlyfHeader.decode(stream);
if (glyph.numberOfContours > 0) this._decodeSimple(glyph, stream);
else if (glyph.numberOfContours < 0) this._decodeComposite(glyph, stream, startPos);
return glyph;
}
_decodeSimple(glyph, stream) {
// this is a simple glyph
glyph.points = [];
let endPtsOfContours = new $gfJaN$restructure.Array($gfJaN$restructure.uint16, glyph.numberOfContours).decode(stream);
glyph.instructions = new $gfJaN$restructure.Array($gfJaN$restructure.uint8, $gfJaN$restructure.uint16).decode(stream);
let flags = [];
let numCoords = endPtsOfContours[endPtsOfContours.length - 1] + 1;
while(flags.length < numCoords){
var flag = stream.readUInt8();
flags.push(flag);
// check for repeat flag
if (flag & $f680320fa07ef53d$var$REPEAT) {
let count = stream.readUInt8();
for(let j = 0; j < count; j++)flags.push(flag);
}
}
for(var i = 0; i < flags.length; i++){
var flag = flags[i];
let point = new $f680320fa07ef53d$export$baf26146a414f24a(!!(flag & $f680320fa07ef53d$var$ON_CURVE), endPtsOfContours.indexOf(i) >= 0, 0, 0);
glyph.points.push(point);
}
let px = 0;
for(var i = 0; i < flags.length; i++){
var flag = flags[i];
glyph.points[i].x = px = this._parseGlyphCoord(stream, px, flag & $f680320fa07ef53d$var$X_SHORT_VECTOR, flag & $f680320fa07ef53d$var$SAME_X);
}
let py = 0;
for(var i = 0; i < flags.length; i++){
var flag = flags[i];
glyph.points[i].y = py = this._parseGlyphCoord(stream, py, flag & $f680320fa07ef53d$var$Y_SHORT_VECTOR, flag & $f680320fa07ef53d$var$SAME_Y);
}
if (this._font._variationProcessor) {
let points = glyph.points.slice();
points.push(...this._getPhantomPoints(glyph));
this._font._variationProcessor.transformPoints(this.id, points);
glyph.phantomPoints = points.slice(-4);
}
return;
}
_decodeComposite(glyph, stream, offset = 0) {
// this is a composite glyph
glyph.components = [];
let haveInstructions = false;
let flags = $f680320fa07ef53d$var$MORE_COMPONENTS;
while(flags & $f680320fa07ef53d$var$MORE_COMPONENTS){
flags = stream.readUInt16BE();
let gPos = stream.pos - offset;
let glyphID = stream.readUInt16BE();
if (!haveInstructions) haveInstructions = (flags & $f680320fa07ef53d$var$WE_HAVE_INSTRUCTIONS) !== 0;
if (flags & $f680320fa07ef53d$var$ARG_1_AND_2_ARE_WORDS) {
var dx = stream.readInt16BE();
var dy = stream.readInt16BE();
} else {
var dx = stream.readInt8();
var dy = stream.readInt8();
}
var component = new $f680320fa07ef53d$var$Component(glyphID, dx, dy);
component.pos = gPos;
if (flags & $f680320fa07ef53d$var$WE_HAVE_A_SCALE) // fixed number with 14 bits of fraction
component.scaleX = component.scaleY = (stream.readUInt8() << 24 | stream.readUInt8() << 16) / 1073741824;
else if (flags & $f680320fa07ef53d$var$WE_HAVE_AN_X_AND_Y_SCALE) {
component.scaleX = (stream.readUInt8() << 24 | stream.readUInt8() << 16) / 1073741824;
component.scaleY = (stream.readUInt8() << 24 | stream.readUInt8() << 16) / 1073741824;
} else if (flags & $f680320fa07ef53d$var$WE_HAVE_A_TWO_BY_TWO) {
component.scaleX = (stream.readUInt8() << 24 | stream.readUInt8() << 16) / 1073741824;
component.scale01 = (stream.readUInt8() << 24 | stream.readUInt8() << 16) / 1073741824;
component.scale10 = (stream.readUInt8() << 24 | stream.readUInt8() << 16) / 1073741824;
component.scaleY = (stream.readUInt8() << 24 | stream.readUInt8() << 16) / 1073741824;
}
glyph.components.push(component);
}
if (this._font._variationProcessor) {
let points = [];
for(let j = 0; j < glyph.components.length; j++){
var component = glyph.components[j];
points.push(new $f680320fa07ef53d$export$baf26146a414f24a(true, true, component.dx, component.dy));
}
points.push(...this._getPhantomPoints(glyph));
this._font._variationProcessor.transformPoints(this.id, points);
glyph.phantomPoints = points.splice(-4, 4);
for(let i = 0; i < points.length; i++){
let point = points[i];
glyph.components[i].dx = point.x;
glyph.components[i].dy = point.y;
}
}
return haveInstructions;
}
_getPhantomPoints(glyph) {
let cbox = this._getCBox(true);
if (this._metrics == null) this._metrics = (0, $0e4f52d7996e478b$export$2e2bcd8739ae039).prototype._getMetrics.call(this, cbox);
let { advanceWidth: advanceWidth, advanceHeight: advanceHeight, leftBearing: leftBearing, topBearing: topBearing } = this._metrics;
return [
new $f680320fa07ef53d$export$baf26146a414f24a(false, true, glyph.xMin - leftBearing, 0),
new $f680320fa07ef53d$export$baf26146a414f24a(false, true, glyph.xMin - leftBearing + advanceWidth, 0),
new $f680320fa07ef53d$export$baf26146a414f24a(false, true, 0, glyph.yMax + topBearing),
new $f680320fa07ef53d$export$baf26146a414f24a(false, true, 0, glyph.yMax + topBearing + advanceHeight)
];
}
// Decodes font data, resolves composite glyphs, and returns an array of contours
_getContours() {
let glyph = this._decode();
if (!glyph) return [];
let points = [];
if (glyph.numberOfContours < 0) // resolve composite glyphs
for (let component of glyph.components){
let contours = this._font.getGlyph(component.glyphID)._getContours();
for(let i = 0; i < contours.length; i++){
let contour = contours[i];
for(let j = 0; j < contour.length; j++){
let point = contour[j];
let x = point.x * component.scaleX + point.y * component.scale01 + component.dx;
let y = point.y * component.scaleY + point.x * component.scale10 + component.dy;
points.push(new $f680320fa07ef53d$export$baf26146a414f24a(point.onCurve, point.endContour, x, y));
}
}
}
else points = glyph.points || [];
// Recompute and cache metrics if we performed variation processing, and don't have an HVAR table
if (glyph.phantomPoints && !this._font.directory.tables.HVAR) {
this._metrics.advanceWidth = glyph.phantomPoints[1].x - glyph.phantomPoints[0].x;
this._metrics.advanceHeight = glyph.phantomPoints[3].y - glyph.phantomPoints[2].y;
this._metrics.leftBearing = glyph.xMin - glyph.phantomPoints[0].x;
this._metrics.topBearing = glyph.phantomPoints[2].y - glyph.yMax;
}
let contours = [];
let cur = [];
for(let k = 0; k < points.length; k++){
var point = points[k];
cur.push(point);
if (point.endContour) {
contours.push(cur);
cur = [];
}
}
return contours;
}
_getMetrics() {
if (this._metrics) return this._metrics;
let cbox = this._getCBox(true);
super._getMetrics(cbox);
if (this._font._variationProcessor && !this._font.HVAR) // No HVAR table, decode the glyph. This triggers recomputation of metrics.
this.path;
return this._metrics;
}
// Converts contours to a Path object that can be rendered
_getPath() {
let contours = this._getContours();
let path = new (0, $67ee4828d81adb28$export$2e2bcd8739ae039);
for(let i = 0; i < contours.length; i++){
let contour = contours[i];
let firstPt = contour[0];
let lastPt = contour[contour.length - 1];
let start = 0;
if (firstPt.onCurve) {
// The first point will be consumed by the moveTo command, so skip in the loop
var curvePt = null;
start = 1;
} else {
if (lastPt.onCurve) // Start at the last point if the first point is off curve and the last point is on curve
firstPt = lastPt;
else // Start at the middle if both the first and last points are off curve
firstPt = new $f680320fa07ef53d$export$baf26146a414f24a(false, false, (firstPt.x + lastPt.x) / 2, (firstPt.y + lastPt.y) / 2);
var curvePt = firstPt;
}
path.moveTo(firstPt.x, firstPt.y);
for(let j = start; j < contour.length; j++){
let pt = contour[j];
let prevPt = j === 0 ? firstPt : contour[j - 1];
if (prevPt.onCurve && pt.onCurve) path.lineTo(pt.x, pt.y);
else if (prevPt.onCurve && !pt.onCurve) var curvePt = pt;
else if (!prevPt.onCurve && !pt.onCurve) {
let midX = (prevPt.x + pt.x) / 2;
let midY = (prevPt.y + pt.y) / 2;
path.quadraticCurveTo(prevPt.x, prevPt.y, midX, midY);
var curvePt = pt;
} else if (!prevPt.onCurve && pt.onCurve) {
path.quadraticCurveTo(curvePt.x, curvePt.y, pt.x, pt.y);
var curvePt = null;
} else throw new Error("Unknown TTF path state");
}
// Connect the first and last points
if (curvePt) path.quadraticCurveTo(curvePt.x, curvePt.y, firstPt.x, firstPt.y);
path.closePath();
}
return path;
}
constructor(...args){
super(...args);
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'TTF');
}
}
class $7ee0705195f3b047$export$2e2bcd8739ae039 extends (0, $0e4f52d7996e478b$export$2e2bcd8739ae039) {
_getName() {
if (this._font.CFF2) return super._getName();
return this._font['CFF '].getGlyphName(this.id);
}
bias(s) {
if (s.length < 1240) return 107;
else if (s.length < 33900) return 1131;
else return 32768;
}
_getPath() {
let cff = this._font.CFF2 || this._font['CFF '];
let { stream: stream } = cff;
let str = cff.topDict.CharStrings[this.id];
let end = str.offset + str.length;
stream.pos = str.offset;
let path = new (0, $67ee4828d81adb28$export$2e2bcd8739ae039);
let stack = [];
let trans = [];
let width = null;
let nStems = 0;
let x = 0, y = 0;
let usedGsubrs;
let usedSubrs;
let open = false;
this._usedGsubrs = usedGsubrs = {};
this._usedSubrs = usedSubrs = {};
let gsubrs = cff.globalSubrIndex || [];
let gsubrsBias = this.bias(gsubrs);
let privateDict = cff.privateDictForGlyph(this.id) || {};
let subrs = privateDict.Subrs || [];
let subrsBias = this.bias(subrs);
let vstore = cff.topDict.vstore && cff.topDict.vstore.itemVariationStore;
let vsindex = privateDict.vsindex;
let variationProcessor = this._font._variationProcessor;
function checkWidth() {
if (width == null) width = stack.shift() + privateDict.nominalWidthX;
}
function parseStems() {
if (stack.length % 2 !== 0) checkWidth();
nStems += stack.length >> 1;
return stack.length = 0;
}
function moveTo(x, y) {
if (open) path.closePath();
path.moveTo(x, y);
open = true;
}
let parse = function() {
while(stream.pos < end){
let op = stream.readUInt8();
if (op < 32) {
let index, subr, phase;
let c1x, c1y, c2x, c2y, c3x, c3y;
let c4x, c4y, c5x, c5y, c6x, c6y;
let pts;
switch(op){
case 1:
case 3:
case 18:
case 23:
parseStems();
break;
case 4:
if (stack.length > 1) checkWidth();
y += stack.shift();
moveTo(x, y);
break;
case 5:
while(stack.length >= 2){
x += stack.shift();
y += stack.shift();
path.lineTo(x, y);
}
break;
case 6:
case 7:
phase = op === 6;
while(stack.length >= 1){
if (phase) x += stack.shift();
else y += stack.shift();
path.lineTo(x, y);
phase = !phase;
}
break;
case 8:
while(stack.length > 0){
c1x = x + stack.shift();
c1y = y + stack.shift();
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
x = c2x + stack.shift();
y = c2y + stack.shift();
path.bezierCurveTo(c1x, c1y, c2x, c2y, x, y);
}
break;
case 10:
index = stack.pop() + subrsBias;
subr = subrs[index];
if (subr) {
usedSubrs[index] = true;
let p = stream.pos;
let e = end;
stream.pos = subr.offset;
end = subr.offset + subr.length;
parse();
stream.pos = p;
end = e;
}
break;
case 11:
if (cff.version >= 2) break;
return;
case 14:
if (cff.version >= 2) break;
if (stack.length > 0) checkWidth();
if (open) {
path.closePath();
open = false;
}
break;
case 15:
if (cff.version < 2) throw new Error('vsindex operator not supported in CFF v1');
vsindex = stack.pop();
break;
case 16:
{
if (cff.version < 2) throw new Error('blend operator not supported in CFF v1');
if (!variationProcessor) throw new Error('blend operator in non-variation font');
let blendVector = variationProcessor.getBlendVector(vstore, vsindex);
let numBlends = stack.pop();
let numOperands = numBlends * blendVector.length;
let delta = stack.length - numOperands;
let base = delta - numBlends;
for(let i = 0; i < numBlends; i++){
let sum = stack[base + i];
for(let j = 0; j < blendVector.length; j++)sum += blendVector[j] * stack[delta++];
stack[base + i] = sum;
}
while(numOperands--)stack.pop();
break;
}
case 19:
case 20:
parseStems();
stream.pos += nStems + 7 >> 3;
break;
case 21:
if (stack.length > 2) checkWidth();
x += stack.shift();
y += stack.shift();
moveTo(x, y);
break;
case 22:
if (stack.length > 1) checkWidth();
x += stack.shift();
moveTo(x, y);
break;
case 24:
while(stack.length >= 8){
c1x = x + stack.shift();
c1y = y + stack.shift();
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
x = c2x + stack.shift();
y = c2y + stack.shift();
path.bezierCurveTo(c1x, c1y, c2x, c2y, x, y);
}
x += stack.shift();
y += stack.shift();
path.lineTo(x, y);
break;
case 25:
while(stack.length >= 8){
x += stack.shift();
y += stack.shift();
path.lineTo(x, y);
}
c1x = x + stack.shift();
c1y = y + stack.shift();
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
x = c2x + stack.shift();
y = c2y + stack.shift();
path.bezierCurveTo(c1x, c1y, c2x, c2y, x, y);
break;
case 26:
if (stack.length % 2) x += stack.shift();
while(stack.length >= 4){
c1x = x;
c1y = y + stack.shift();
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
x = c2x;
y = c2y + stack.shift();
path.bezierCurveTo(c1x, c1y, c2x, c2y, x, y);
}
break;
case 27:
if (stack.length % 2) y += stack.shift();
while(stack.length >= 4){
c1x = x + stack.shift();
c1y = y;
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
x = c2x + stack.shift();
y = c2y;
path.bezierCurveTo(c1x, c1y, c2x, c2y, x, y);
}
break;
case 28:
stack.push(stream.readInt16BE());
break;
case 29:
index = stack.pop() + gsubrsBias;
subr = gsubrs[index];
if (subr) {
usedGsubrs[index] = true;
let p = stream.pos;
let e = end;
stream.pos = subr.offset;
end = subr.offset + subr.length;
parse();
stream.pos = p;
end = e;
}
break;
case 30:
case 31:
phase = op === 31;
while(stack.length >= 4){
if (phase) {
c1x = x + stack.shift();
c1y = y;
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
y = c2y + stack.shift();
x = c2x + (stack.length === 1 ? stack.shift() : 0);
} else {
c1x = x;
c1y = y + stack.shift();
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
x = c2x + stack.shift();
y = c2y + (stack.length === 1 ? stack.shift() : 0);
}
path.bezierCurveTo(c1x, c1y, c2x, c2y, x, y);
phase = !phase;
}
break;
case 12:
op = stream.readUInt8();
switch(op){
case 3:
let a = stack.pop();
let b = stack.pop();
stack.push(a && b ? 1 : 0);
break;
case 4:
a = stack.pop();
b = stack.pop();
stack.push(a || b ? 1 : 0);
break;
case 5:
a = stack.pop();
stack.push(a ? 0 : 1);
break;
case 9:
a = stack.pop();
stack.push(Math.abs(a));
break;
case 10:
a = stack.pop();
b = stack.pop();
stack.push(a + b);
break;
case 11:
a = stack.pop();
b = stack.pop();
stack.push(a - b);
break;
case 12:
a = stack.pop();
b = stack.pop();
stack.push(a / b);
break;
case 14:
a = stack.pop();
stack.push(-a);
break;
case 15:
a = stack.pop();
b = stack.pop();
stack.push(a === b ? 1 : 0);
break;
case 18:
stack.pop();
break;
case 20:
let val = stack.pop();
let idx = stack.pop();
trans[idx] = val;
break;
case 21:
idx = stack.pop();
stack.push(trans[idx] || 0);
break;
case 22:
let s1 = stack.pop();
let s2 = stack.pop();
let v1 = stack.pop();
let v2 = stack.pop();
stack.push(v1 <= v2 ? s1 : s2);
break;
case 23:
stack.push(Math.random());
break;
case 24:
a = stack.pop();
b = stack.pop();
stack.push(a * b);
break;
case 26:
a = stack.pop();
stack.push(Math.sqrt(a));
break;
case 27:
a = stack.pop();
stack.push(a, a);
break;
case 28:
a = stack.pop();
b = stack.pop();
stack.push(b, a);
break;
case 29:
idx = stack.pop();
if (idx < 0) idx = 0;
else if (idx > stack.length - 1) idx = stack.length - 1;
stack.push(stack[idx]);
break;
case 30:
let n = stack.pop();
let j = stack.pop();
if (j >= 0) while(j > 0){
var t = stack[n - 1];
for(let i = n - 2; i >= 0; i--)stack[i + 1] = stack[i];
stack[0] = t;
j--;
}
else while(j < 0){
var t = stack[0];
for(let i = 0; i <= n; i++)stack[i] = stack[i + 1];
stack[n - 1] = t;
j++;
}
break;
case 34:
c1x = x + stack.shift();
c1y = y;
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
c3x = c2x + stack.shift();
c3y = c2y;
c4x = c3x + stack.shift();
c4y = c3y;
c5x = c4x + stack.shift();
c5y = c4y;
c6x = c5x + stack.shift();
c6y = c5y;
x = c6x;
y = c6y;
path.bezierCurveTo(c1x, c1y, c2x, c2y, c3x, c3y);
path.bezierCurveTo(c4x, c4y, c5x, c5y, c6x, c6y);
break;
case 35:
pts = [];
for(let i = 0; i <= 5; i++){
x += stack.shift();
y += stack.shift();
pts.push(x, y);
}
path.bezierCurveTo(...pts.slice(0, 6));
path.bezierCurveTo(...pts.slice(6));
stack.shift(); // fd
break;
case 36:
c1x = x + stack.shift();
c1y = y + stack.shift();
c2x = c1x + stack.shift();
c2y = c1y + stack.shift();
c3x = c2x + stack.shift();
c3y = c2y;
c4x = c3x + stack.shift();
c4y = c3y;
c5x = c4x + stack.shift();
c5y = c4y + stack.shift();
c6x = c5x + stack.shift();
c6y = c5y;
x = c6x;
y = c6y;
path.bezierCurveTo(c1x, c1y, c2x, c2y, c3x, c3y);
path.bezierCurveTo(c4x, c4y, c5x, c5y, c6x, c6y);
break;
case 37:
let startx = x;
let starty = y;
pts = [];
for(let i = 0; i <= 4; i++){
x += stack.shift();
y += stack.shift();
pts.push(x, y);
}
if (Math.abs(x - startx) > Math.abs(y - starty)) {
x += stack.shift();
y = starty;
} else {
x = startx;
y += stack.shift();
}
pts.push(x, y);
path.bezierCurveTo(...pts.slice(0, 6));
path.bezierCurveTo(...pts.slice(6));
break;
default:
throw new Error(`Unknown op: 12 ${op}`);
}
break;
default:
throw new Error(`Unknown op: ${op}`);
}
} else if (op < 247) stack.push(op - 139);
else if (op < 251) {
var b1 = stream.readUInt8();
stack.push((op - 247) * 256 + b1 + 108);
} else if (op < 255) {
var b1 = stream.readUInt8();
stack.push(-(op - 251) * 256 - b1 - 108);
} else stack.push(stream.readInt32BE() / 65536);
}
};
parse();
if (open) path.closePath();
return path;
}
constructor(...args){
super(...args);
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'CFF');
}
}
let $55855d6d316b015e$var$SBIXImage = new $gfJaN$restructure.Struct({
originX: $gfJaN$restructure.uint16,
originY: $gfJaN$restructure.uint16,
type: new $gfJaN$restructure.String(4),
data: new $gfJaN$restructure.Buffer((t)=>t.parent.buflen - t._currentOffset)
});
class $55855d6d316b015e$export$2e2bcd8739ae039 extends (0, $f680320fa07ef53d$export$2e2bcd8739ae039) {
/**
* Returns an object representing a glyph image at the given point size.
* The object has a data property with a Buffer containing the actual image data,
* along with the image type, and origin.
*
* @param {number} size
* @return {object}
*/ getImageForSize(size) {
for(let i = 0; i < this._font.sbix.imageTables.length; i++){
var table = this._font.sbix.imageTables[i];
if (table.ppem >= size) break;
}
let offsets = table.imageOffsets;
let start = offsets[this.id];
let end = offsets[this.id + 1];
if (start === end) return null;
this._font.stream.pos = start;
return $55855d6d316b015e$var$SBIXImage.decode(this._font.stream, {
buflen: end - start
});
}
render(ctx, size) {
let img = this.getImageForSize(size);
if (img != null) {
let scale = size / this._font.unitsPerEm;
ctx.image(img.data, {
height: size,
x: img.originX,
y: (this.bbox.minY - img.originY) * scale
});
}
if (this._font.sbix.flags.renderOutlines) super.render(ctx, size);
}
constructor(...args){
super(...args);
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'SBIX');
}
}
class $42d9dbd2de9ee2d8$var$COLRLayer {
constructor(glyph, color){
this.glyph = glyph;
this.color = color;
}
}
class $42d9dbd2de9ee2d8$export$2e2bcd8739ae039 extends (0, $0e4f52d7996e478b$export$2e2bcd8739ae039) {
_getBBox() {
let bbox = new (0, $0e2da1c4ce69e8ad$export$2e2bcd8739ae039);
for(let i = 0; i < this.layers.length; i++){
let layer = this.layers[i];
let b = layer.glyph.bbox;
bbox.addPoint(b.minX, b.minY);
bbox.addPoint(b.maxX, b.maxY);
}
return bbox;
}
/**
* Returns an array of objects containing the glyph and color for
* each layer in the composite color glyph.
* @type {object[]}
*/ get layers() {
let cpal = this._font.CPAL;
let colr = this._font.COLR;
let low = 0;
let high = colr.baseGlyphRecord.length - 1;
while(low <= high){
let mid = low + high >> 1;
var rec = colr.baseGlyphRecord[mid];
if (this.id < rec.gid) high = mid - 1;
else if (this.id > rec.gid) low = mid + 1;
else {
var baseLayer = rec;
break;
}
}
// if base glyph not found in COLR table,
// default to normal glyph from glyf or CFF
if (baseLayer == null) {
var g = this._font._getBaseGlyph(this.id);
var color = {
red: 0,
green: 0,
blue: 0,
alpha: 255
};
return [
new $42d9dbd2de9ee2d8$var$COLRLayer(g, color)
];
}
// otherwise, return an array of all the layers
let layers = [];
for(let i = baseLayer.firstLayerIndex; i < baseLayer.firstLayerIndex + baseLayer.numLayers; i++){
var rec = colr.layerRecords[i];
var color = cpal.colorRecords[rec.paletteIndex];
var g = this._font._getBaseGlyph(rec.gid);
layers.push(new $42d9dbd2de9ee2d8$var$COLRLayer(g, color));
}
return layers;
}
render(ctx, size) {
for (let { glyph: glyph, color: color } of this.layers){
ctx.fillColor([
color.red,
color.green,
color.blue
], color.alpha / 255 * 100);
glyph.render(ctx, size);
}
return;
}
constructor(...args){
super(...args);
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'COLR');
}
}
const $7586bb9ea67c41d8$var$TUPLES_SHARE_POINT_NUMBERS = 0x8000;
const $7586bb9ea67c41d8$var$TUPLE_COUNT_MASK = 0x0fff;
const $7586bb9ea67c41d8$var$EMBEDDED_TUPLE_COORD = 0x8000;
const $7586bb9ea67c41d8$var$INTERMEDIATE_TUPLE = 0x4000;
const $7586bb9ea67c41d8$var$PRIVATE_POINT_NUMBERS = 0x2000;
const $7586bb9ea67c41d8$var$TUPLE_INDEX_MASK = 0x0fff;
const $7586bb9ea67c41d8$var$POINTS_ARE_WORDS = 0x80;
const $7586bb9ea67c41d8$var$POINT_RUN_COUNT_MASK = 0x7f;
const $7586bb9ea67c41d8$var$DELTAS_ARE_ZERO = 0x80;
const $7586bb9ea67c41d8$var$DELTAS_ARE_WORDS = 0x40;
const $7586bb9ea67c41d8$var$DELTA_RUN_COUNT_MASK = 0x3f;
class $7586bb9ea67c41d8$export$2e2bcd8739ae039 {
normalizeCoords(coords) {
// the default mapping is linear along each axis, in two segments:
// from the minValue to defaultValue, and from defaultValue to maxValue.
let normalized = [];
for(var i = 0; i < this.font.fvar.axis.length; i++){
let axis = this.font.fvar.axis[i];
if (coords[i] < axis.defaultValue) normalized.push((coords[i] - axis.defaultValue + Number.EPSILON) / (axis.defaultValue - axis.minValue + Number.EPSILON));
else normalized.push((coords[i] - axis.defaultValue + Number.EPSILON) / (axis.maxValue - axis.defaultValue + Number.EPSILON));
}
// if there is an avar table, the normalized value is calculated
// by interpolating between the two nearest mapped values.
if (this.font.avar) for(var i = 0; i < this.font.avar.segment.length; i++){
let segment = this.font.avar.segment[i];
for(let j = 0; j < segment.correspondence.length; j++){
let pair = segment.correspondence[j];
if (j >= 1 && normalized[i] < pair.fromCoord) {
let prev = segment.correspondence[j - 1];
normalized[i] = ((normalized[i] - prev.fromCoord) * (pair.toCoord - prev.toCoord) + Number.EPSILON) / (pair.fromCoord - prev.fromCoord + Number.EPSILON) + prev.toCoord;
break;
}
}
}
return normalized;
}
transformPoints(gid, glyphPoints) {
if (!this.font.fvar || !this.font.gvar) return;
let { gvar: gvar } = this.font;
if (gid >= gvar.glyphCount) return;
let offset = gvar.offsets[gid];
if (offset === gvar.offsets[gid + 1]) return;
// Read the gvar data for this glyph
let { stream: stream } = this.font;
stream.pos = offset;
if (stream.pos >= stream.length) return;
let tupleCount = stream.readUInt16BE();
let offsetToData = offset + stream.readUInt16BE();
if (tupleCount & $7586bb9ea67c41d8$var$TUPLES_SHARE_POINT_NUMBERS) {
var here = stream.pos;
stream.pos = offsetToData;
var sharedPoints = this.decodePoints();
offsetToData = stream.pos;
stream.pos = here;
}
let origPoints = glyphPoints.map((pt)=>pt.copy());
tupleCount &= $7586bb9ea67c41d8$var$TUPLE_COUNT_MASK;
for(let i = 0; i < tupleCount; i++){
let tupleDataSize = stream.readUInt16BE();
let tupleIndex = stream.readUInt16BE();
if (tupleIndex & $7586bb9ea67c41d8$var$EMBEDDED_TUPLE_COORD) {
var tupleCoords = [];
for(let a = 0; a < gvar.axisCount; a++)tupleCoords.push(stream.readInt16BE() / 16384);
} else {
if ((tupleIndex & $7586bb9ea67c41d8$var$TUPLE_INDEX_MASK) >= gvar.globalCoordCount) throw new Error('Invalid gvar table');
var tupleCoords = gvar.globalCoords[tupleIndex & $7586bb9ea67c41d8$var$TUPLE_INDEX_MASK];
}
if (tupleIndex & $7586bb9ea67c41d8$var$INTERMEDIATE_TUPLE) {
var startCoords = [];
for(let a = 0; a < gvar.axisCount; a++)startCoords.push(stream.readInt16BE() / 16384);
var endCoords = [];
for(let a = 0; a < gvar.axisCount; a++)endCoords.push(stream.readInt16BE() / 16384);
}
// Get the factor at which to apply this tuple
let factor = this.tupleFactor(tupleIndex, tupleCoords, startCoords, endCoords);
if (factor === 0) {
offsetToData += tupleDataSize;
continue;
}
var here = stream.pos;
stream.pos = offsetToData;
if (tupleIndex & $7586bb9ea67c41d8$var$PRIVATE_POINT_NUMBERS) var points = this.decodePoints();
else var points = sharedPoints;
// points.length = 0 means there are deltas for all points
let nPoints = points.length === 0 ? glyphPoints.length : points.length;
let xDeltas = this.decodeDeltas(nPoints);
let yDeltas = this.decodeDeltas(nPoints);
if (points.length === 0) for(let i = 0; i < glyphPoints.length; i++){
var point = glyphPoints[i];
point.x += Math.round(xDeltas[i] * factor);
point.y += Math.round(yDeltas[i] * factor);
}
else {
let outPoints = origPoints.map((pt)=>pt.copy());
let hasDelta = glyphPoints.map(()=>false);
for(let i = 0; i < points.length; i++){
let idx = points[i];
if (idx < glyphPoints.length) {
let point = outPoints[idx];
hasDelta[idx] = true;
point.x += xDeltas[i] * factor;
point.y += yDeltas[i] * factor;
}
}
this.interpolateMissingDeltas(outPoints, origPoints, hasDelta);
for(let i = 0; i < glyphPoints.length; i++){
let deltaX = outPoints[i].x - origPoints[i].x;
let deltaY = outPoints[i].y - origPoints[i].y;
glyphPoints[i].x = Math.round(glyphPoints[i].x + deltaX);
glyphPoints[i].y = Math.round(glyphPoints[i].y + deltaY);
}
}
offsetToData += tupleDataSize;
stream.pos = here;
}
}
decodePoints() {
let stream = this.font.stream;
let count = stream.readUInt8();
if (count & $7586bb9ea67c41d8$var$POINTS_ARE_WORDS) count = (count & $7586bb9ea67c41d8$var$POINT_RUN_COUNT_MASK) << 8 | stream.readUInt8();
let points = new Uint16Array(count);
let i = 0;
let point = 0;
while(i < count){
let run = stream.readUInt8();
let runCount = (run & $7586bb9ea67c41d8$var$POINT_RUN_COUNT_MASK) + 1;
let fn = run & $7586bb9ea67c41d8$var$POINTS_ARE_WORDS ? stream.readUInt16 : stream.readUInt8;
for(let j = 0; j < runCount && i < count; j++){
point += fn.call(stream);
points[i++] = point;
}
}
return points;
}
decodeDeltas(count) {
let stream = this.font.stream;
let i = 0;
let deltas = new Int16Array(count);
while(i < count){
let run = stream.readUInt8();
let runCount = (run & $7586bb9ea67c41d8$var$DELTA_RUN_COUNT_MASK) + 1;
if (run & $7586bb9ea67c41d8$var$DELTAS_ARE_ZERO) i += runCount;
else {
let fn = run & $7586bb9ea67c41d8$var$DELTAS_ARE_WORDS ? stream.readInt16BE : stream.readInt8;
for(let j = 0; j < runCount && i < count; j++)deltas[i++] = fn.call(stream);
}
}
return deltas;
}
tupleFactor(tupleIndex, tupleCoords, startCoords, endCoords) {
let normalized = this.normalizedCoords;
let { gvar: gvar } = this.font;
let factor = 1;
for(let i = 0; i < gvar.axisCount; i++){
if (tupleCoords[i] === 0) continue;
if (normalized[i] === 0) return 0;
if ((tupleIndex & $7586bb9ea67c41d8$var$INTERMEDIATE_TUPLE) === 0) {
if (normalized[i] < Math.min(0, tupleCoords[i]) || normalized[i] > Math.max(0, tupleCoords[i])) return 0;
factor = (factor * normalized[i] + Number.EPSILON) / (tupleCoords[i] + Number.EPSILON);
} else {
if (normalized[i] < startCoords[i] || normalized[i] > endCoords[i]) return 0;
else if (normalized[i] < tupleCoords[i]) factor = factor * (normalized[i] - startCoords[i] + Number.EPSILON) / (tupleCoords[i] - startCoords[i] + Number.EPSILON);
else factor = factor * (endCoords[i] - normalized[i] + Number.EPSILON) / (endCoords[i] - tupleCoords[i] + Number.EPSILON);
}
}
return factor;
}
// Interpolates points without delta values.
// Needed for the Ø and Q glyphs in Skia.
// Algorithm from Freetype.
interpolateMissingDeltas(points, inPoints, hasDelta) {
if (points.length === 0) return;
let point = 0;
while(point < points.length){
let firstPoint = point;
// find the end point of the contour
let endPoint = point;
let pt = points[endPoint];
while(!pt.endContour)pt = points[++endPoint];
// find the first point that has a delta
while(point <= endPoint && !hasDelta[point])point++;
if (point > endPoint) continue;
let firstDelta = point;
let curDelta = point;
point++;
while(point <= endPoint){
// find the next point with a delta, and interpolate intermediate points
if (hasDelta[point]) {
this.deltaInterpolate(curDelta + 1, point - 1, curDelta, point, inPoints, points);
curDelta = point;
}
point++;
}
// shift contour if we only have a single delta
if (curDelta === firstDelta) this.deltaShift(firstPoint, endPoint, curDelta, inPoints, points);
else {
// otherwise, handle the remaining points at the end and beginning of the contour
this.deltaInterpolate(curDelta + 1, endPoint, curDelta, firstDelta, inPoints, points);
if (firstDelta > 0) this.deltaInterpolate(firstPoint, firstDelta - 1, curDelta, firstDelta, inPoints, points);
}
point = endPoint + 1;
}
}
deltaInterpolate(p1, p2, ref1, ref2, inPoints, outPoints) {
if (p1 > p2) return;
let iterable = [
'x',
'y'
];
for(let i = 0; i < iterable.length; i++){
let k = iterable[i];
if (inPoints[ref1][k] > inPoints[ref2][k]) {
var p = ref1;
ref1 = ref2;
ref2 = p;
}
let in1 = inPoints[ref1][k];
let in2 = inPoints[ref2][k];
let out1 = outPoints[ref1][k];
let out2 = outPoints[ref2][k];
// If the reference points have the same coordinate but different
// delta, inferred delta is zero. Otherwise interpolate.
if (in1 !== in2 || out1 === out2) {
let scale = in1 === in2 ? 0 : (out2 - out1) / (in2 - in1);
for(let p = p1; p <= p2; p++){
let out = inPoints[p][k];
if (out <= in1) out += out1 - in1;
else if (out >= in2) out += out2 - in2;
else out = out1 + (out - in1) * scale;
outPoints[p][k] = out;
}
}
}
}
deltaShift(p1, p2, ref, inPoints, outPoints) {
let deltaX = outPoints[ref].x - inPoints[ref].x;
let deltaY = outPoints[ref].y - inPoints[ref].y;
if (deltaX === 0 && deltaY === 0) return;
for(let p = p1; p <= p2; p++)if (p !== ref) {
outPoints[p].x += deltaX;
outPoints[p].y += deltaY;
}
}
getAdvanceAdjustment(gid, table) {
let outerIndex, innerIndex;
if (table.advanceWidthMapping) {
let idx = gid;
if (idx >= table.advanceWidthMapping.mapCount) idx = table.advanceWidthMapping.mapCount - 1;
let entryFormat = table.advanceWidthMapping.entryFormat;
({ outerIndex: outerIndex, innerIndex: innerIndex } = table.advanceWidthMapping.mapData[idx]);
} else {
outerIndex = 0;
innerIndex = gid;
}
return this.getDelta(table.itemVariationStore, outerIndex, innerIndex);
}
// See pseudo code from `Font Variations Overview'
// in the OpenType specification.
getDelta(itemStore, outerIndex, innerIndex) {
if (outerIndex >= itemStore.itemVariationData.length) return 0;
let varData = itemStore.itemVariationData[outerIndex];
if (innerIndex >= varData.deltaSets.length) return 0;
let deltaSet = varData.deltaSets[innerIndex];
let blendVector = this.getBlendVector(itemStore, outerIndex);
let netAdjustment = 0;
for(let master = 0; master < varData.regionIndexCount; master++)netAdjustment += deltaSet.deltas[master] * blendVector[master];
return netAdjustment;
}
getBlendVector(itemStore, outerIndex) {
let varData = itemStore.itemVariationData[outerIndex];
if (this.blendVectors.has(varData)) return this.blendVectors.get(varData);
let normalizedCoords = this.normalizedCoords;
let blendVector = [];
// outer loop steps through master designs to be blended
for(let master = 0; master < varData.regionIndexCount; master++){
let scalar = 1;
let regionIndex = varData.regionIndexes[master];
let axes = itemStore.variationRegionList.variationRegions[regionIndex];
// inner loop steps through axes in this region
for(let j = 0; j < axes.length; j++){
let axis = axes[j];
let axisScalar;
// compute the scalar contribution of this axis
// ignore invalid ranges
if (axis.startCoord > axis.peakCoord || axis.peakCoord > axis.endCoord) axisScalar = 1;
else if (axis.startCoord < 0 && axis.endCoord > 0 && axis.peakCoord !== 0) axisScalar = 1;
else if (axis.peakCoord === 0) axisScalar = 1;
else if (normalizedCoords[j] < axis.startCoord || normalizedCoords[j] > axis.endCoord) axisScalar = 0;
else {
if (normalizedCoords[j] === axis.peakCoord) axisScalar = 1;
else if (normalizedCoords[j] < axis.peakCoord) axisScalar = (normalizedCoords[j] - axis.startCoord + Number.EPSILON) / (axis.peakCoord - axis.startCoord + Number.EPSILON);
else axisScalar = (axis.endCoord - normalizedCoords[j] + Number.EPSILON) / (axis.endCoord - axis.peakCoord + Number.EPSILON);
}
// take product of all the axis scalars
scalar *= axisScalar;
}
blendVector[master] = scalar;
}
this.blendVectors.set(varData, blendVector);
return blendVector;
}
constructor(font, coords){
this.font = font;
this.normalizedCoords = this.normalizeCoords(coords);
this.blendVectors = new Map;
}
}
const $a8ac370803cb82cf$var$resolved = Promise.resolve();
class $a8ac370803cb82cf$export$2e2bcd8739ae039 {
includeGlyph(glyph) {
if (typeof glyph === 'object') glyph = glyph.id;
if (this.mapping[glyph] == null) {
this.glyphs.push(glyph);
this.mapping[glyph] = this.glyphs.length - 1;
}
return this.mapping[glyph];
}
constructor(font){
this.font = font;
this.glyphs = [];
this.mapping = {};
// always include the missing glyph
this.includeGlyph(0);
}
}
// Flags for simple glyphs
const $2784eedf0b35a048$var$ON_CURVE = 1;
const $2784eedf0b35a048$var$X_SHORT_VECTOR = 2;
const $2784eedf0b35a048$var$Y_SHORT_VECTOR = 4;
const $2784eedf0b35a048$var$REPEAT = 8;
const $2784eedf0b35a048$var$SAME_X = 16;
const $2784eedf0b35a048$var$SAME_Y = 32;
class $2784eedf0b35a048$var$Point {
static size(val) {
return val >= 0 && val <= 255 ? 1 : 2;
}
static encode(stream, value) {
if (value >= 0 && value <= 255) stream.writeUInt8(value);
else stream.writeInt16BE(value);
}
}
let $2784eedf0b35a048$var$Glyf = new $gfJaN$restructure.Struct({
numberOfContours: $gfJaN$restructure.int16,
xMin: $gfJaN$restructure.int16,
yMin: $gfJaN$restructure.int16,
xMax: $gfJaN$restructure.int16,
yMax: $gfJaN$restructure.int16,
endPtsOfContours: new $gfJaN$restructure.Array($gfJaN$restructure.uint16, 'numberOfContours'),
instructions: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, $gfJaN$restructure.uint16),
flags: new $gfJaN$restructure.Array($gfJaN$restructure.uint8, 0),
xPoints: new $gfJaN$restructure.Array($2784eedf0b35a048$var$Point, 0),
yPoints: new $gfJaN$restructure.Array($2784eedf0b35a048$var$Point, 0)
});
class $2784eedf0b35a048$export$2e2bcd8739ae039 {
encodeSimple(path, instructions = []) {
let endPtsOfContours = [];
let xPoints = [];
let yPoints = [];
let flags = [];
let same = 0;
let lastX = 0, lastY = 0, lastFlag = 0;
let pointCount = 0;
for(let i = 0; i < path.commands.length; i++){
let c = path.commands[i];
for(let j = 0; j < c.args.length; j += 2){
let x = c.args[j];
let y = c.args[j + 1];
let flag = 0;
// If the ending point of a quadratic curve is the midpoint
// between the control point and the control point of the next
// quadratic curve, we can omit the ending point.
if (c.command === 'quadraticCurveTo' && j === 2) {
let next = path.commands[i + 1];
if (next && next.command === 'quadraticCurveTo') {
let midX = (lastX + next.args[0]) / 2;
let midY = (lastY + next.args[1]) / 2;
if (x === midX && y === midY) continue;
}
}
// All points except control points are on curve.
if (!(c.command === 'quadraticCurveTo' && j === 0)) flag |= $2784eedf0b35a048$var$ON_CURVE;
flag = this._encodePoint(x, lastX, xPoints, flag, $2784eedf0b35a048$var$X_SHORT_VECTOR, $2784eedf0b35a048$var$SAME_X);
flag = this._encodePoint(y, lastY, yPoints, flag, $2784eedf0b35a048$var$Y_SHORT_VECTOR, $2784eedf0b35a048$var$SAME_Y);
if (flag === lastFlag && same < 255) {
flags[flags.length - 1] |= $2784eedf0b35a048$var$REPEAT;
same++;
} else {
if (same > 0) {
flags.push(same);
same = 0;
}
flags.push(flag);
lastFlag = flag;
}
lastX = x;
lastY = y;
pointCount++;
}
if (c.command === 'closePath') endPtsOfContours.push(pointCount - 1);
}
// Close the path if the last command didn't already
if (path.commands.length > 1 && path.commands[path.commands.length - 1].command !== 'closePath') endPtsOfContours.push(pointCount - 1);
let bbox = path.bbox;
let glyf = {
numberOfContours: endPtsOfContours.length,
xMin: bbox.minX,
yMin: bbox.minY,
xMax: bbox.maxX,
yMax: bbox.maxY,
endPtsOfContours: endPtsOfContours,
instructions: instructions,
flags: flags,
xPoints: xPoints,
yPoints: yPoints
};
let size = $2784eedf0b35a048$var$Glyf.size(glyf);
let tail = 4 - size % 4;
let stream = new $gfJaN$restructure.EncodeStream(size + tail);
$2784eedf0b35a048$var$Glyf.encode(stream, glyf);
// Align to 4-byte length
if (tail !== 0) stream.fill(0, tail);
return stream.buffer;
}
_encodePoint(value, last, points, flag, shortFlag, sameFlag) {
let diff = value - last;
if (value === last) flag |= sameFlag;
else {
if (-255 <= diff && diff <= 255) {
flag |= shortFlag;
if (diff < 0) diff = -diff;
else flag |= sameFlag;
}
points.push(diff);
}
return flag;
}
}
class $fe042f4b88f46896$export$2e2bcd8739ae039 extends (0, $a8ac370803cb82cf$export$2e2bcd8739ae039) {
_addGlyph(gid) {
let glyph = this.font.getGlyph(gid);
let glyf = glyph._decode();
// get the offset to the glyph from the loca table
let curOffset = this.font.loca.offsets[gid];
let nextOffset = this.font.loca.offsets[gid + 1];
let stream = this.font._getTableStream('glyf');
stream.pos += curOffset;
let buffer = stream.readBuffer(nextOffset - curOffset);
// if it is a compound glyph, include its components
if (glyf && glyf.numberOfContours < 0) {
buffer = new Uint8Array(buffer);
let view = new DataView(buffer.buffer);
for (let component of glyf.components){
gid = this.includeGlyph(component.glyphID);
view.setUint16(component.pos, gid);
}
} else if (glyf && this.font._variationProcessor) // If this is a TrueType variation glyph, re-encode the path
buffer = this.glyphEncoder.encodeSimple(glyph.path, glyf.instructions);
this.glyf.push(buffer);
this.loca.offsets.push(this.offset);
this.hmtx.metrics.push({
advance: glyph.advanceWidth,
bearing: glyph._getMetrics().leftBearing
});
this.offset += buffer.length;
return this.glyf.length - 1;
}
encode() {
// tables required by PDF spec:
// head, hhea, loca, maxp, cvt , prep, glyf, hmtx, fpgm
//
// additional tables required for standalone fonts:
// name, cmap, OS/2, post
this.glyf = [];
this.offset = 0;
this.loca = {
offsets: [],
version: this.font.loca.version
};
this.hmtx = {
metrics: [],
bearings: []
};
// include all the glyphs
// not using a for loop because we need to support adding more
// glyphs to the array as we go, and CoffeeScript caches the length.
let i = 0;
while(i < this.glyphs.length)this._addGlyph(this.glyphs[i++]);
let maxp = (0, ($parcel$interopDefault($gfJaN$clone)))(this.font.maxp);
maxp.numGlyphs = this.glyf.length;
this.loca.offsets.push(this.offset);
let head = (0, ($parcel$interopDefault($gfJaN$clone)))(this.font.head);
head.indexToLocFormat = this.loca.version;
let hhea = (0, ($parcel$interopDefault($gfJaN$clone)))(this.font.hhea);
hhea.numberOfMetrics = this.hmtx.metrics.length;
// map = []
// for index in [0...256]
// if index < @numGlyphs
// map[index] = index
// else
// map[index] = 0
//
// cmapTable =
// version: 0
// length: 262
// language: 0
// codeMap: map
//
// cmap =
// version: 0
// numSubtables: 1
// tables: [
// platformID: 1
// encodingID: 0
// table: cmapTable
// ]
// TODO: subset prep, cvt, fpgm?
return (0, $df50e1efe10a1247$export$2e2bcd8739ae039).toBuffer({
tables: {
head: head,
hhea: hhea,
loca: this.loca,
maxp: maxp,
'cvt ': this.font['cvt '],
prep: this.font.prep,
glyf: this.glyf,
hmtx: this.hmtx,
fpgm: this.font.fpgm
}
});
}
constructor(font){
super(font);
this.glyphEncoder = new (0, $2784eedf0b35a048$export$2e2bcd8739ae039);
}
}
class $ec40f80c07a4e08a$export$2e2bcd8739ae039 extends (0, $a8ac370803cb82cf$export$2e2bcd8739ae039) {
subsetCharstrings() {
this.charstrings = [];
let gsubrs = {};
for (let gid of this.glyphs){
this.charstrings.push(this.cff.getCharString(gid));
let glyph = this.font.getGlyph(gid);
let path = glyph.path; // this causes the glyph to be parsed
for(let subr in glyph._usedGsubrs)gsubrs[subr] = true;
}
this.gsubrs = this.subsetSubrs(this.cff.globalSubrIndex, gsubrs);
}
subsetSubrs(subrs, used) {
let res = [];
for(let i = 0; i < subrs.length; i++){
let subr = subrs[i];
if (used[i]) {
this.cff.stream.pos = subr.offset;
res.push(this.cff.stream.readBuffer(subr.length));
} else res.push(new Uint8Array([
11
])); // return
}
return res;
}
subsetFontdict(topDict) {
topDict.FDArray = [];
topDict.FDSelect = {
version: 0,
fds: []
};
let used_fds = {};
let used_subrs = [];
let fd_select = {};
for (let gid of this.glyphs){
let fd = this.cff.fdForGlyph(gid);
if (fd == null) continue;
if (!used_fds[fd]) {
topDict.FDArray.push(Object.assign({}, this.cff.topDict.FDArray[fd]));
used_subrs.push({});
fd_select[fd] = topDict.FDArray.length - 1;
}
used_fds[fd] = true;
topDict.FDSelect.fds.push(fd_select[fd]);
let glyph = this.font.getGlyph(gid);
let path = glyph.path; // this causes the glyph to be parsed
for(let subr in glyph._usedSubrs)used_subrs[fd_select[fd]][subr] = true;
}
for(let i = 0; i < topDict.FDArray.length; i++){
let dict = topDict.FDArray[i];
delete dict.FontName;
if (dict.Private && dict.Private.Subrs) {
dict.Private = Object.assign({}, dict.Private);
dict.Private.Subrs = this.subsetSubrs(dict.Private.Subrs, used_subrs[i]);
}
}
return;
}
createCIDFontdict(topDict) {
let used_subrs = {};
for (let gid of this.glyphs){
let glyph = this.font.getGlyph(gid);
let path = glyph.path; // this causes the glyph to be parsed
for(let subr in glyph._usedSubrs)used_subrs[subr] = true;
}
let privateDict = Object.assign({}, this.cff.topDict.Private);
if (this.cff.topDict.Private && this.cff.topDict.Private.Subrs) privateDict.Subrs = this.subsetSubrs(this.cff.topDict.Private.Subrs, used_subrs);
topDict.FDArray = [
{
Private: privateDict
}
];
return topDict.FDSelect = {
version: 3,
nRanges: 1,
ranges: [
{
first: 0,
fd: 0
}
],
sentinel: this.charstrings.length
};
}
addString(string) {
if (!string) return null;
if (!this.strings) this.strings = [];
this.strings.push(string);
return (0, $860d3574d7fa3a51$export$2e2bcd8739ae039).length + this.strings.length - 1;
}
encode() {
this.subsetCharstrings();
let charset = {
version: this.charstrings.length > 255 ? 2 : 1,
ranges: [
{
first: 1,
nLeft: this.charstrings.length - 2
}
]
};
let topDict = Object.assign({}, this.cff.topDict);
topDict.Private = null;
topDict.charset = charset;
topDict.Encoding = null;
topDict.CharStrings = this.charstrings;
for (let key of [
'version',
'Notice',
'Copyright',
'FullName',
'FamilyName',
'Weight',
'PostScript',
'BaseFontName',
'FontName'
])topDict[key] = this.addString(this.cff.string(topDict[key]));
topDict.ROS = [
this.addString('Adobe'),
this.addString('Identity'),
0
];
topDict.CIDCount = this.charstrings.length;
if (this.cff.isCIDFont) this.subsetFontdict(topDict);
else this.createCIDFontdict(topDict);
let top = {
version: 1,
hdrSize: this.cff.hdrSize,
offSize: 4,
header: this.cff.header,
nameIndex: [
this.cff.postscriptName
],
topDictIndex: [
topDict
],
stringIndex: this.strings,
globalSubrIndex: this.gsubrs
};
return (0, $5b547cf9e5da519b$export$2e2bcd8739ae039).toBuffer(top);
}
constructor(font){
super(font);
this.cff = this.font['CFF '];
if (!this.cff) throw new Error('Not a CFF Font');
}
}
class $0a8ef2660a6ce4b6$export$2e2bcd8739ae039 {
static probe(buffer) {
let format = (0, $66a5b9fb5318558a$export$3d28c1996ced1f14).decode(buffer.slice(0, 4));
return format === 'true' || format === 'OTTO' || format === String.fromCharCode(0, 1, 0, 0);
}
setDefaultLanguage(lang = null) {
this.defaultLanguage = lang;
}
_getTable(table) {
if (!(table.tag in this._tables)) try {
this._tables[table.tag] = this._decodeTable(table);
} catch (e) {
if ($59aa4ed98453e1d4$export$bd5c5d8b8dcafd78) {
console.error(`Error decoding table ${table.tag}`);
console.error(e.stack);
}
}
return this._tables[table.tag];
}
_getTableStream(tag) {
let table = this.directory.tables[tag];
if (table) {
this.stream.pos = table.offset;
return this.stream;
}
return null;
}
_decodeDirectory() {
return this.directory = (0, $df50e1efe10a1247$export$2e2bcd8739ae039).decode(this.stream, {
_startOffset: 0
});
}
_decodeTable(table) {
let pos = this.stream.pos;
let stream = this._getTableStream(table.tag);
let result = (0, $5825c04ce8f7102d$export$2e2bcd8739ae039)[table.tag].decode(stream, this, table.length);
this.stream.pos = pos;
return result;
}
/**
* Gets a string from the font's `name` table
* `lang` is a BCP-47 language code.
* @return {string}
*/ getName(key, lang = this.defaultLanguage || $59aa4ed98453e1d4$export$42940898df819940) {
let record = this.name && this.name.records[key];
if (record) // Attempt to retrieve the entry, depending on which translation is available:
return record[lang] || record[this.defaultLanguage] || record[$59aa4ed98453e1d4$export$42940898df819940] || record['en'] || record[Object.keys(record)[0]] // Seriously, ANY language would be fine
|| null;
return null;
}
/**
* The unique PostScript name for this font, e.g. "Helvetica-Bold"
* @type {string}
*/ get postscriptName() {
return this.getName('postscriptName');
}
/**
* The font's full name, e.g. "Helvetica Bold"
* @type {string}
*/ get fullName() {
return this.getName('fullName');
}
/**
* The font's family name, e.g. "Helvetica"
* @type {string}
*/ get familyName() {
return this.getName('fontFamily');
}
/**
* The font's sub-family, e.g. "Bold".
* @type {string}
*/ get subfamilyName() {
return this.getName('fontSubfamily');
}
/**
* The font's copyright information
* @type {string}
*/ get copyright() {
return this.getName('copyright');
}
/**
* The font's version number
* @type {string}
*/ get version() {
return this.getName('version');
}
/**
* The font’s [ascender](https://en.wikipedia.org/wiki/Ascender_(typography))
* @type {number}
*/ get ascent() {
return this.hhea.ascent;
}
/**
* The font’s [descender](https://en.wikipedia.org/wiki/Descender)
* @type {number}
*/ get descent() {
return this.hhea.descent;
}
/**
* The amount of space that should be included between lines
* @type {number}
*/ get lineGap() {
return this.hhea.lineGap;
}
/**
* The offset from the normal underline position that should be used
* @type {number}
*/ get underlinePosition() {
return this.post.underlinePosition;
}
/**
* The weight of the underline that should be used
* @type {number}
*/ get underlineThickness() {
return this.post.underlineThickness;
}
/**
* If this is an italic font, the angle the cursor should be drawn at to match the font design
* @type {number}
*/ get italicAngle() {
return this.post.italicAngle;
}
/**
* The height of capital letters above the baseline.
* See [here](https://en.wikipedia.org/wiki/Cap_height) for more details.
* @type {number}
*/ get capHeight() {
let os2 = this['OS/2'];
return os2 ? os2.capHeight : this.ascent;
}
/**
* The height of lower case letters in the font.
* See [here](https://en.wikipedia.org/wiki/X-height) for more details.
* @type {number}
*/ get xHeight() {
let os2 = this['OS/2'];
return os2 ? os2.xHeight : 0;
}
/**
* The number of glyphs in the font.
* @type {number}
*/ get numGlyphs() {
return this.maxp.numGlyphs;
}
/**
* The size of the font’s internal coordinate grid
* @type {number}
*/ get unitsPerEm() {
return this.head.unitsPerEm;
}
/**
* The font’s bounding box, i.e. the box that encloses all glyphs in the font.
* @type {BBox}
*/ get bbox() {
return Object.freeze(new (0, $0e2da1c4ce69e8ad$export$2e2bcd8739ae039)(this.head.xMin, this.head.yMin, this.head.xMax, this.head.yMax));
}
get _cmapProcessor() {
return new (0, $0d6e160064c86e50$export$2e2bcd8739ae039)(this.cmap);
}
/**
* An array of all of the unicode code points supported by the font.
* @type {number[]}
*/ get characterSet() {
return this._cmapProcessor.getCharacterSet();
}
/**
* Returns whether there is glyph in the font for the given unicode code point.
*
* @param {number} codePoint
* @return {boolean}
*/ hasGlyphForCodePoint(codePoint) {
return !!this._cmapProcessor.lookup(codePoint);
}
/**
* Maps a single unicode code point to a Glyph object.
* Does not perform any advanced substitutions (there is no context to do so).
*
* @param {number} codePoint
* @return {Glyph}
*/ glyphForCodePoint(codePoint) {
return this.getGlyph(this._cmapProcessor.lookup(codePoint), [
codePoint
]);
}
/**
* Returns an array of Glyph objects for the given string.
* This is only a one-to-one mapping from characters to glyphs.
* For most uses, you should use font.layout (described below), which
* provides a much more advanced mapping supporting AAT and OpenType shaping.
*
* @param {string} string
* @return {Glyph[]}
*/ glyphsForString(string) {
let glyphs = [];
let len = string.length;
let idx = 0;
let last = -1;
let state = -1;
while(idx <= len){
let code = 0;
let nextState = 0;
if (idx < len) {
// Decode the next codepoint from UTF 16
code = string.charCodeAt(idx++);
if (0xd800 <= code && code <= 0xdbff && idx < len) {
let next = string.charCodeAt(idx);
if (0xdc00 <= next && next <= 0xdfff) {
idx++;
code = ((code & 0x3ff) << 10) + (next & 0x3ff) + 0x10000;
}
}
// Compute the next state: 1 if the next codepoint is a variation selector, 0 otherwise.
nextState = 0xfe00 <= code && code <= 0xfe0f || 0xe0100 <= code && code <= 0xe01ef ? 1 : 0;
} else idx++;
if (state === 0 && nextState === 1) // Variation selector following normal codepoint.
glyphs.push(this.getGlyph(this._cmapProcessor.lookup(last, code), [
last,
code
]));
else if (state === 0 && nextState === 0) // Normal codepoint following normal codepoint.
glyphs.push(this.glyphForCodePoint(last));
last = code;
state = nextState;
}
return glyphs;
}
get _layoutEngine() {
return new (0, $9d641258c9d7180d$export$2e2bcd8739ae039)(this);
}
/**
* Returns a GlyphRun object, which includes an array of Glyphs and GlyphPositions for the given string.
*
* @param {string} string
* @param {string[]} [userFeatures]
* @param {string} [script]
* @param {string} [language]
* @param {string} [direction]
* @return {GlyphRun}
*/ layout(string, userFeatures, script, language, direction) {
return this._layoutEngine.layout(string, userFeatures, script, language, direction);
}
/**
* Returns an array of strings that map to the given glyph id.
* @param {number} gid - glyph id
*/ stringsForGlyph(gid) {
return this._layoutEngine.stringsForGlyph(gid);
}
/**
* An array of all [OpenType feature tags](https://www.microsoft.com/typography/otspec/featuretags.htm)
* (or mapped AAT tags) supported by the font.
* The features parameter is an array of OpenType feature tags to be applied in addition to the default set.
* If this is an AAT font, the OpenType feature tags are mapped to AAT features.
*
* @type {string[]}
*/ get availableFeatures() {
return this._layoutEngine.getAvailableFeatures();
}
getAvailableFeatures(script, language) {
return this._layoutEngine.getAvailableFeatures(script, language);
}
_getBaseGlyph(glyph, characters = []) {
if (!this._glyphs[glyph]) {
if (this.directory.tables.glyf) this._glyphs[glyph] = new (0, $f680320fa07ef53d$export$2e2bcd8739ae039)(glyph, characters, this);
else if (this.directory.tables['CFF '] || this.directory.tables.CFF2) this._glyphs[glyph] = new (0, $7ee0705195f3b047$export$2e2bcd8739ae039)(glyph, characters, this);
}
return this._glyphs[glyph] || null;
}
/**
* Returns a glyph object for the given glyph id.
* You can pass the array of code points this glyph represents for
* your use later, and it will be stored in the glyph object.
*
* @param {number} glyph
* @param {number[]} characters
* @return {Glyph}
*/ getGlyph(glyph, characters = []) {
if (!this._glyphs[glyph]) {
if (this.directory.tables.sbix) this._glyphs[glyph] = new (0, $55855d6d316b015e$export$2e2bcd8739ae039)(glyph, characters, this);
else if (this.directory.tables.COLR && this.directory.tables.CPAL) this._glyphs[glyph] = new (0, $42d9dbd2de9ee2d8$export$2e2bcd8739ae039)(glyph, characters, this);
else this._getBaseGlyph(glyph, characters);
}
return this._glyphs[glyph] || null;
}
/**
* Returns a Subset for this font.
* @return {Subset}
*/ createSubset() {
if (this.directory.tables['CFF ']) return new (0, $ec40f80c07a4e08a$export$2e2bcd8739ae039)(this);
return new (0, $fe042f4b88f46896$export$2e2bcd8739ae039)(this);
}
/**
* Returns an object describing the available variation axes
* that this font supports. Keys are setting tags, and values
* contain the axis name, range, and default value.
*
* @type {object}
*/ get variationAxes() {
let res = {};
if (!this.fvar) return res;
for (let axis of this.fvar.axis)res[axis.axisTag.trim()] = {
name: axis.name.en,
min: axis.minValue,
default: axis.defaultValue,
max: axis.maxValue
};
return res;
}
/**
* Returns an object describing the named variation instances
* that the font designer has specified. Keys are variation names
* and values are the variation settings for this instance.
*
* @type {object}
*/ get namedVariations() {
let res = {};
if (!this.fvar) return res;
for (let instance of this.fvar.instance){
let settings = {};
for(let i = 0; i < this.fvar.axis.length; i++){
let axis = this.fvar.axis[i];
settings[axis.axisTag.trim()] = instance.coord[i];
}
res[instance.name.en] = settings;
}
return res;
}
/**
* Returns a new font with the given variation settings applied.
* Settings can either be an instance name, or an object containing
* variation tags as specified by the `variationAxes` property.
*
* @param {object} settings
* @return {TTFFont}
*/ getVariation(settings) {
if (!(this.directory.tables.fvar && (this.directory.tables.gvar && this.directory.tables.glyf || this.directory.tables.CFF2))) throw new Error('Variations require a font with the fvar, gvar and glyf, or CFF2 tables.');
if (typeof settings === 'string') settings = this.namedVariations[settings];
if (typeof settings !== 'object') throw new Error('Variation settings must be either a variation name or settings object.');
// normalize the coordinates
let coords = this.fvar.axis.map((axis, i)=>{
let axisTag = axis.axisTag.trim();
if (axisTag in settings) return Math.max(axis.minValue, Math.min(axis.maxValue, settings[axisTag]));
else return axis.defaultValue;
});
let stream = new $gfJaN$restructure.DecodeStream(this.stream.buffer);
stream.pos = this._directoryPos;
let font = new $0a8ef2660a6ce4b6$export$2e2bcd8739ae039(stream, coords);
font._tables = this._tables;
return font;
}
get _variationProcessor() {
if (!this.fvar) return null;
let variationCoords = this.variationCoords;
// Ignore if no variation coords and not CFF2
if (!variationCoords && !this.CFF2) return null;
if (!variationCoords) variationCoords = this.fvar.axis.map((axis)=>axis.defaultValue);
return new (0, $7586bb9ea67c41d8$export$2e2bcd8739ae039)(this, variationCoords);
}
// Standardized format plugin API
getFont(name) {
return this.getVariation(name);
}
constructor(stream, variationCoords = null){
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'TTF');
this.defaultLanguage = null;
this.stream = stream;
this.variationCoords = variationCoords;
this._directoryPos = this.stream.pos;
this._tables = {};
this._glyphs = {};
this._decodeDirectory();
// define properties for each table to lazily parse
for(let tag in this.directory.tables){
let table = this.directory.tables[tag];
if ((0, $5825c04ce8f7102d$export$2e2bcd8739ae039)[tag] && table.length > 0) Object.defineProperty(this, tag, {
get: this._getTable.bind(this, table)
});
}
}
}
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0a8ef2660a6ce4b6$export$2e2bcd8739ae039.prototype, "bbox", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0a8ef2660a6ce4b6$export$2e2bcd8739ae039.prototype, "_cmapProcessor", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0a8ef2660a6ce4b6$export$2e2bcd8739ae039.prototype, "characterSet", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0a8ef2660a6ce4b6$export$2e2bcd8739ae039.prototype, "_layoutEngine", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0a8ef2660a6ce4b6$export$2e2bcd8739ae039.prototype, "variationAxes", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0a8ef2660a6ce4b6$export$2e2bcd8739ae039.prototype, "namedVariations", null);
(0, $gfJaN$swchelperscjs_ts_decoratecjs._)([
(0, $3bda6911913b43f0$export$69a3209f1a06c04d)
], $0a8ef2660a6ce4b6$export$2e2bcd8739ae039.prototype, "_variationProcessor", null);
let $89f72d2d7c9afc0d$var$WOFFDirectoryEntry = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
offset: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, 'void', {
type: 'global'
}),
compLength: $gfJaN$restructure.uint32,
length: $gfJaN$restructure.uint32,
origChecksum: $gfJaN$restructure.uint32
});
let $89f72d2d7c9afc0d$var$WOFFDirectory = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
flavor: $gfJaN$restructure.uint32,
length: $gfJaN$restructure.uint32,
numTables: $gfJaN$restructure.uint16,
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
totalSfntSize: $gfJaN$restructure.uint32,
majorVersion: $gfJaN$restructure.uint16,
minorVersion: $gfJaN$restructure.uint16,
metaOffset: $gfJaN$restructure.uint32,
metaLength: $gfJaN$restructure.uint32,
metaOrigLength: $gfJaN$restructure.uint32,
privOffset: $gfJaN$restructure.uint32,
privLength: $gfJaN$restructure.uint32,
tables: new $gfJaN$restructure.Array($89f72d2d7c9afc0d$var$WOFFDirectoryEntry, 'numTables')
});
$89f72d2d7c9afc0d$var$WOFFDirectory.process = function() {
let tables = {};
for (let table of this.tables)tables[table.tag] = table;
this.tables = tables;
};
var $89f72d2d7c9afc0d$export$2e2bcd8739ae039 = $89f72d2d7c9afc0d$var$WOFFDirectory;
class $8a0a49baaf5d834d$export$2e2bcd8739ae039 extends (0, $0a8ef2660a6ce4b6$export$2e2bcd8739ae039) {
static probe(buffer) {
return (0, $66a5b9fb5318558a$export$3d28c1996ced1f14).decode(buffer.slice(0, 4)) === 'wOFF';
}
_decodeDirectory() {
this.directory = (0, $89f72d2d7c9afc0d$export$2e2bcd8739ae039).decode(this.stream, {
_startOffset: 0
});
}
_getTableStream(tag) {
let table = this.directory.tables[tag];
if (table) {
this.stream.pos = table.offset;
if (table.compLength < table.length) {
this.stream.pos += 2; // skip deflate header
let outBuffer = new Uint8Array(table.length);
let buf = (0, ($parcel$interopDefault($gfJaN$tinyinflate)))(this.stream.readBuffer(table.compLength - 2), outBuffer);
return new $gfJaN$restructure.DecodeStream(buf);
} else return this.stream;
}
return null;
}
constructor(...args){
super(...args);
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'WOFF');
}
}
class $44b9edca0e403d6d$export$2e2bcd8739ae039 extends (0, $f680320fa07ef53d$export$2e2bcd8739ae039) {
_decode() {
// We have to decode in advance (in WOFF2Font), so just return the pre-decoded data.
return this._font._transformedGlyphs[this.id];
}
_getCBox() {
return this.path.bbox;
}
constructor(...args){
super(...args);
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'WOFF2');
}
}
const $2f0bfd9a5c1d7b58$var$Base128 = {
decode (stream) {
let result = 0;
let iterable = [
0,
1,
2,
3,
4
];
for(let j = 0; j < iterable.length; j++){
let i = iterable[j];
let code = stream.readUInt8();
// If any of the top seven bits are set then we're about to overflow.
if (result & 0xe0000000) throw new Error('Overflow');
result = result << 7 | code & 0x7f;
if ((code & 0x80) === 0) return result;
}
throw new Error('Bad base 128 number');
}
};
let $2f0bfd9a5c1d7b58$var$knownTags = [
'cmap',
'head',
'hhea',
'hmtx',
'maxp',
'name',
'OS/2',
'post',
'cvt ',
'fpgm',
'glyf',
'loca',
'prep',
'CFF ',
'VORG',
'EBDT',
'EBLC',
'gasp',
'hdmx',
'kern',
'LTSH',
'PCLT',
'VDMX',
'vhea',
'vmtx',
'BASE',
'GDEF',
'GPOS',
'GSUB',
'EBSC',
'JSTF',
'MATH',
'CBDT',
'CBLC',
'COLR',
'CPAL',
'SVG ',
'sbix',
'acnt',
'avar',
'bdat',
'bloc',
'bsln',
'cvar',
'fdsc',
'feat',
'fmtx',
'fvar',
'gvar',
'hsty',
'just',
'lcar',
'mort',
'morx',
'opbd',
'prop',
'trak',
'Zapf',
'Silf',
'Glat',
'Gloc',
'Feat',
'Sill'
];
let $2f0bfd9a5c1d7b58$var$WOFF2DirectoryEntry = new $gfJaN$restructure.Struct({
flags: $gfJaN$restructure.uint8,
customTag: new $gfJaN$restructure.Optional(new $gfJaN$restructure.String(4), (t)=>(t.flags & 0x3f) === 0x3f),
tag: (t)=>t.customTag || $2f0bfd9a5c1d7b58$var$knownTags[t.flags & 0x3f],
length: $2f0bfd9a5c1d7b58$var$Base128,
transformVersion: (t)=>t.flags >>> 6 & 0x03,
transformed: (t)=>t.tag === 'glyf' || t.tag === 'loca' ? t.transformVersion === 0 : t.transformVersion !== 0,
transformLength: new $gfJaN$restructure.Optional($2f0bfd9a5c1d7b58$var$Base128, (t)=>t.transformed)
});
let $2f0bfd9a5c1d7b58$var$WOFF2Directory = new $gfJaN$restructure.Struct({
tag: new $gfJaN$restructure.String(4),
flavor: $gfJaN$restructure.uint32,
length: $gfJaN$restructure.uint32,
numTables: $gfJaN$restructure.uint16,
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint16),
totalSfntSize: $gfJaN$restructure.uint32,
totalCompressedSize: $gfJaN$restructure.uint32,
majorVersion: $gfJaN$restructure.uint16,
minorVersion: $gfJaN$restructure.uint16,
metaOffset: $gfJaN$restructure.uint32,
metaLength: $gfJaN$restructure.uint32,
metaOrigLength: $gfJaN$restructure.uint32,
privOffset: $gfJaN$restructure.uint32,
privLength: $gfJaN$restructure.uint32,
tables: new $gfJaN$restructure.Array($2f0bfd9a5c1d7b58$var$WOFF2DirectoryEntry, 'numTables')
});
$2f0bfd9a5c1d7b58$var$WOFF2Directory.process = function() {
let tables = {};
for(let i = 0; i < this.tables.length; i++){
let table = this.tables[i];
tables[table.tag] = table;
}
return this.tables = tables;
};
var $2f0bfd9a5c1d7b58$export$2e2bcd8739ae039 = $2f0bfd9a5c1d7b58$var$WOFF2Directory;
class $333fb94547d9fb5c$export$2e2bcd8739ae039 extends (0, $0a8ef2660a6ce4b6$export$2e2bcd8739ae039) {
static probe(buffer) {
return (0, $66a5b9fb5318558a$export$3d28c1996ced1f14).decode(buffer.slice(0, 4)) === 'wOF2';
}
_decodeDirectory() {
this.directory = (0, $2f0bfd9a5c1d7b58$export$2e2bcd8739ae039).decode(this.stream);
this._dataPos = this.stream.pos;
}
_decompress() {
// decompress data and setup table offsets if we haven't already
if (!this._decompressed) {
this.stream.pos = this._dataPos;
let buffer = this.stream.readBuffer(this.directory.totalCompressedSize);
let decompressedSize = 0;
for(let tag in this.directory.tables){
let entry = this.directory.tables[tag];
entry.offset = decompressedSize;
decompressedSize += entry.transformLength != null ? entry.transformLength : entry.length;
}
let decompressed = (0, ($parcel$interopDefault($gfJaN$brotlidecompressjs)))(buffer, decompressedSize);
if (!decompressed) throw new Error('Error decoding compressed data in WOFF2');
this.stream = new $gfJaN$restructure.DecodeStream(decompressed);
this._decompressed = true;
}
}
_decodeTable(table) {
this._decompress();
return super._decodeTable(table);
}
// Override this method to get a glyph and return our
// custom subclass if there is a glyf table.
_getBaseGlyph(glyph, characters = []) {
if (!this._glyphs[glyph]) {
if (this.directory.tables.glyf && this.directory.tables.glyf.transformed) {
if (!this._transformedGlyphs) this._transformGlyfTable();
return this._glyphs[glyph] = new (0, $44b9edca0e403d6d$export$2e2bcd8739ae039)(glyph, characters, this);
} else return super._getBaseGlyph(glyph, characters);
}
}
_transformGlyfTable() {
this._decompress();
this.stream.pos = this.directory.tables.glyf.offset;
let table = $333fb94547d9fb5c$var$GlyfTable.decode(this.stream);
let glyphs = [];
for(let index = 0; index < table.numGlyphs; index++){
let glyph = {};
let nContours = table.nContours.readInt16BE();
glyph.numberOfContours = nContours;
if (nContours > 0) {
let nPoints = [];
let totalPoints = 0;
for(let i = 0; i < nContours; i++){
let r = $333fb94547d9fb5c$var$read255UInt16(table.nPoints);
totalPoints += r;
nPoints.push(totalPoints);
}
glyph.points = $333fb94547d9fb5c$var$decodeTriplet(table.flags, table.glyphs, totalPoints);
for(let i = 0; i < nContours; i++)glyph.points[nPoints[i] - 1].endContour = true;
var instructionSize = $333fb94547d9fb5c$var$read255UInt16(table.glyphs);
} else if (nContours < 0) {
let haveInstructions = (0, $f680320fa07ef53d$export$2e2bcd8739ae039).prototype._decodeComposite.call({
_font: this
}, glyph, table.composites);
if (haveInstructions) var instructionSize = $333fb94547d9fb5c$var$read255UInt16(table.glyphs);
}
glyphs.push(glyph);
}
this._transformedGlyphs = glyphs;
}
constructor(...args){
super(...args);
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'WOFF2');
}
}
// Special class that accepts a length and returns a sub-stream for that data
class $333fb94547d9fb5c$var$Substream {
decode(stream, parent) {
return new $gfJaN$restructure.DecodeStream(this._buf.decode(stream, parent));
}
constructor(length){
this.length = length;
this._buf = new $gfJaN$restructure.Buffer(length);
}
}
// This struct represents the entire glyf table
let $333fb94547d9fb5c$var$GlyfTable = new $gfJaN$restructure.Struct({
version: $gfJaN$restructure.uint32,
numGlyphs: $gfJaN$restructure.uint16,
indexFormat: $gfJaN$restructure.uint16,
nContourStreamSize: $gfJaN$restructure.uint32,
nPointsStreamSize: $gfJaN$restructure.uint32,
flagStreamSize: $gfJaN$restructure.uint32,
glyphStreamSize: $gfJaN$restructure.uint32,
compositeStreamSize: $gfJaN$restructure.uint32,
bboxStreamSize: $gfJaN$restructure.uint32,
instructionStreamSize: $gfJaN$restructure.uint32,
nContours: new $333fb94547d9fb5c$var$Substream('nContourStreamSize'),
nPoints: new $333fb94547d9fb5c$var$Substream('nPointsStreamSize'),
flags: new $333fb94547d9fb5c$var$Substream('flagStreamSize'),
glyphs: new $333fb94547d9fb5c$var$Substream('glyphStreamSize'),
composites: new $333fb94547d9fb5c$var$Substream('compositeStreamSize'),
bboxes: new $333fb94547d9fb5c$var$Substream('bboxStreamSize'),
instructions: new $333fb94547d9fb5c$var$Substream('instructionStreamSize')
});
const $333fb94547d9fb5c$var$WORD_CODE = 253;
const $333fb94547d9fb5c$var$ONE_MORE_BYTE_CODE2 = 254;
const $333fb94547d9fb5c$var$ONE_MORE_BYTE_CODE1 = 255;
const $333fb94547d9fb5c$var$LOWEST_U_CODE = 253;
function $333fb94547d9fb5c$var$read255UInt16(stream) {
let code = stream.readUInt8();
if (code === $333fb94547d9fb5c$var$WORD_CODE) return stream.readUInt16BE();
if (code === $333fb94547d9fb5c$var$ONE_MORE_BYTE_CODE1) return stream.readUInt8() + $333fb94547d9fb5c$var$LOWEST_U_CODE;
if (code === $333fb94547d9fb5c$var$ONE_MORE_BYTE_CODE2) return stream.readUInt8() + $333fb94547d9fb5c$var$LOWEST_U_CODE * 2;
return code;
}
function $333fb94547d9fb5c$var$withSign(flag, baseval) {
return flag & 1 ? baseval : -baseval;
}
function $333fb94547d9fb5c$var$decodeTriplet(flags, glyphs, nPoints) {
let y;
let x = y = 0;
let res = [];
for(let i = 0; i < nPoints; i++){
let dx = 0, dy = 0;
let flag = flags.readUInt8();
let onCurve = !(flag >> 7);
flag &= 0x7f;
if (flag < 10) {
dx = 0;
dy = $333fb94547d9fb5c$var$withSign(flag, ((flag & 14) << 7) + glyphs.readUInt8());
} else if (flag < 20) {
dx = $333fb94547d9fb5c$var$withSign(flag, ((flag - 10 & 14) << 7) + glyphs.readUInt8());
dy = 0;
} else if (flag < 84) {
var b0 = flag - 20;
var b1 = glyphs.readUInt8();
dx = $333fb94547d9fb5c$var$withSign(flag, 1 + (b0 & 0x30) + (b1 >> 4));
dy = $333fb94547d9fb5c$var$withSign(flag >> 1, 1 + ((b0 & 0x0c) << 2) + (b1 & 0x0f));
} else if (flag < 120) {
var b0 = flag - 84;
dx = $333fb94547d9fb5c$var$withSign(flag, 1 + (b0 / 12 << 8) + glyphs.readUInt8());
dy = $333fb94547d9fb5c$var$withSign(flag >> 1, 1 + (b0 % 12 >> 2 << 8) + glyphs.readUInt8());
} else if (flag < 124) {
var b1 = glyphs.readUInt8();
let b2 = glyphs.readUInt8();
dx = $333fb94547d9fb5c$var$withSign(flag, (b1 << 4) + (b2 >> 4));
dy = $333fb94547d9fb5c$var$withSign(flag >> 1, ((b2 & 0x0f) << 8) + glyphs.readUInt8());
} else {
dx = $333fb94547d9fb5c$var$withSign(flag, glyphs.readUInt16BE());
dy = $333fb94547d9fb5c$var$withSign(flag >> 1, glyphs.readUInt16BE());
}
x += dx;
y += dy;
res.push(new (0, $f680320fa07ef53d$export$baf26146a414f24a)(onCurve, false, x, y));
}
return res;
}
let $e0b2de9958441c02$var$TTCHeader = new $gfJaN$restructure.VersionedStruct($gfJaN$restructure.uint32, {
0x00010000: {
numFonts: $gfJaN$restructure.uint32,
offsets: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, 'numFonts')
},
0x00020000: {
numFonts: $gfJaN$restructure.uint32,
offsets: new $gfJaN$restructure.Array($gfJaN$restructure.uint32, 'numFonts'),
dsigTag: $gfJaN$restructure.uint32,
dsigLength: $gfJaN$restructure.uint32,
dsigOffset: $gfJaN$restructure.uint32
}
});
class $e0b2de9958441c02$export$2e2bcd8739ae039 {
static probe(buffer) {
return (0, $66a5b9fb5318558a$export$3d28c1996ced1f14).decode(buffer.slice(0, 4)) === 'ttcf';
}
getFont(name) {
for (let offset of this.header.offsets){
let stream = new $gfJaN$restructure.DecodeStream(this.stream.buffer);
stream.pos = offset;
let font = new (0, $0a8ef2660a6ce4b6$export$2e2bcd8739ae039)(stream);
if (font.postscriptName === name || font.postscriptName instanceof Uint8Array && name instanceof Uint8Array && font.postscriptName.every((v, i)=>name[i] === v)) return font;
}
return null;
}
get fonts() {
let fonts = [];
for (let offset of this.header.offsets){
let stream = new $gfJaN$restructure.DecodeStream(this.stream.buffer);
stream.pos = offset;
fonts.push(new (0, $0a8ef2660a6ce4b6$export$2e2bcd8739ae039)(stream));
}
return fonts;
}
constructor(stream){
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'TTC');
this.stream = stream;
if (stream.readString(4) !== 'ttcf') throw new Error('Not a TrueType collection');
this.header = $e0b2de9958441c02$var$TTCHeader.decode(stream);
}
}
let $d0fe640dc6c78783$var$DFontName = new $gfJaN$restructure.String($gfJaN$restructure.uint8);
let $d0fe640dc6c78783$var$DFontData = new $gfJaN$restructure.Struct({
len: $gfJaN$restructure.uint32,
buf: new $gfJaN$restructure.Buffer('len')
});
let $d0fe640dc6c78783$var$Ref = new $gfJaN$restructure.Struct({
id: $gfJaN$restructure.uint16,
nameOffset: $gfJaN$restructure.int16,
attr: $gfJaN$restructure.uint8,
dataOffset: $gfJaN$restructure.uint24,
handle: $gfJaN$restructure.uint32
});
let $d0fe640dc6c78783$var$Type = new $gfJaN$restructure.Struct({
name: new $gfJaN$restructure.String(4),
maxTypeIndex: $gfJaN$restructure.uint16,
refList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, new $gfJaN$restructure.Array($d0fe640dc6c78783$var$Ref, (t)=>t.maxTypeIndex + 1), {
type: 'parent'
})
});
let $d0fe640dc6c78783$var$TypeList = new $gfJaN$restructure.Struct({
length: $gfJaN$restructure.uint16,
types: new $gfJaN$restructure.Array($d0fe640dc6c78783$var$Type, (t)=>t.length + 1)
});
let $d0fe640dc6c78783$var$DFontMap = new $gfJaN$restructure.Struct({
reserved: new $gfJaN$restructure.Reserved($gfJaN$restructure.uint8, 24),
typeList: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, $d0fe640dc6c78783$var$TypeList),
nameListOffset: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint16, 'void')
});
let $d0fe640dc6c78783$var$DFontHeader = new $gfJaN$restructure.Struct({
dataOffset: $gfJaN$restructure.uint32,
map: new $gfJaN$restructure.Pointer($gfJaN$restructure.uint32, $d0fe640dc6c78783$var$DFontMap),
dataLength: $gfJaN$restructure.uint32,
mapLength: $gfJaN$restructure.uint32
});
class $d0fe640dc6c78783$export$2e2bcd8739ae039 {
static probe(buffer) {
let stream = new $gfJaN$restructure.DecodeStream(buffer);
try {
var header = $d0fe640dc6c78783$var$DFontHeader.decode(stream);
} catch (e) {
return false;
}
for (let type of header.map.typeList.types){
if (type.name === 'sfnt') return true;
}
return false;
}
getFont(name) {
if (!this.sfnt) return null;
for (let ref of this.sfnt.refList){
let pos = this.header.dataOffset + ref.dataOffset + 4;
let stream = new $gfJaN$restructure.DecodeStream(this.stream.buffer.slice(pos));
let font = new (0, $0a8ef2660a6ce4b6$export$2e2bcd8739ae039)(stream);
if (font.postscriptName === name || font.postscriptName instanceof Uint8Array && name instanceof Uint8Array && font.postscriptName.every((v, i)=>name[i] === v)) return font;
}
return null;
}
get fonts() {
let fonts = [];
for (let ref of this.sfnt.refList){
let pos = this.header.dataOffset + ref.dataOffset + 4;
let stream = new $gfJaN$restructure.DecodeStream(this.stream.buffer.slice(pos));
fonts.push(new (0, $0a8ef2660a6ce4b6$export$2e2bcd8739ae039)(stream));
}
return fonts;
}
constructor(stream){
(0, $gfJaN$swchelperscjs_define_propertycjs._)(this, "type", 'DFont');
this.stream = stream;
this.header = $d0fe640dc6c78783$var$DFontHeader.decode(this.stream);
for (let type of this.header.map.typeList.types){
for (let ref of type.refList)if (ref.nameOffset >= 0) {
this.stream.pos = ref.nameOffset + this.header.map.nameListOffset;
ref.name = $d0fe640dc6c78783$var$DFontName.decode(this.stream);
} else ref.name = null;
if (type.name === 'sfnt') this.sfnt = type;
}
}
}
// Register font formats
(0, $59aa4ed98453e1d4$export$36b2f24e97d43be)((0, $0a8ef2660a6ce4b6$export$2e2bcd8739ae039));
(0, $59aa4ed98453e1d4$export$36b2f24e97d43be)((0, $8a0a49baaf5d834d$export$2e2bcd8739ae039));
(0, $59aa4ed98453e1d4$export$36b2f24e97d43be)((0, $333fb94547d9fb5c$export$2e2bcd8739ae039));
(0, $59aa4ed98453e1d4$export$36b2f24e97d43be)((0, $e0b2de9958441c02$export$2e2bcd8739ae039));
(0, $59aa4ed98453e1d4$export$36b2f24e97d43be)((0, $d0fe640dc6c78783$export$2e2bcd8739ae039));
$parcel$exportWildcard(module.exports, $59aa4ed98453e1d4$exports);
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"@swc/helpers/cjs/_define_property.cjs":7,"@swc/helpers/cjs/_ts_decorate.cjs":8,"brotli/decompress.js":20,"clone":22,"dfa":23,"fast-deep-equal":24,"restructure":32,"tiny-inflate":33,"unicode-properties":35,"unicode-trie":36}],28:[function(require,module,exports){
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
var e, m
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var nBits = -7
var i = isLE ? (nBytes - 1) : 0
var d = isLE ? -1 : 1
var s = buffer[offset + i]
i += d
e = s & ((1 << (-nBits)) - 1)
s >>= (-nBits)
nBits += eLen
for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
m = e & ((1 << (-nBits)) - 1)
e >>= (-nBits)
nBits += mLen
for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
if (e === 0) {
e = 1 - eBias
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + Math.pow(2, mLen)
e = e - eBias
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
var i = isLE ? 0 : (nBytes - 1)
var d = isLE ? 1 : -1
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
value = Math.abs(value)
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0
e = eMax
} else {
e = Math.floor(Math.log(value) / Math.LN2)
if (value * (c = Math.pow(2, -e)) < 1) {
e--
c *= 2
}
if (e + eBias >= 1) {
value += rt / c
} else {
value += rt * Math.pow(2, 1 - eBias)
}
if (value * c >= 2) {
e++
c /= 2
}
if (e + eBias >= eMax) {
m = 0
e = eMax
} else if (e + eBias >= 1) {
m = ((value * c) - 1) * Math.pow(2, mLen)
e = e + eBias
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
e = 0
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
e = (e << mLen) | m
eLen += mLen
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
buffer[offset + i - d] |= s * 128
}
},{}],29:[function(require,module,exports){
var $kQ2hT$unicodetrie = require("unicode-trie");
var $kQ2hT$base64js = require("base64-js");
function $parcel$interopDefault(a) {
return a && a.__esModule ? a.default : a;
}
"use strict";
const $60ff486a304db230$export$af862512e23cb54 = 0; // Opening punctuation
const $60ff486a304db230$export$9bf3043cb7503aa1 = 1; // Closing punctuation
const $60ff486a304db230$export$6d0b2a5dd774590a = 2; // Closing parenthesis
const $60ff486a304db230$export$bf0b2277bd569ea1 = 3; // Ambiguous quotation
const $60ff486a304db230$export$bad2a840ccda93b6 = 4; // Glue
const $60ff486a304db230$export$fb4028874a74450 = 5; // Non-starters
const $60ff486a304db230$export$463bd1ce0149c55e = 6; // Exclamation/Interrogation
const $60ff486a304db230$export$2e8caadc521d7cbb = 7; // Symbols allowing break after
const $60ff486a304db230$export$bfe27467c1de9413 = 8; // Infix separator
const $60ff486a304db230$export$af5f8d68aad3cd3a = 9; // Prefix
const $60ff486a304db230$export$6b7e017d6825d38f = 10; // Postfix
const $60ff486a304db230$export$8227ca023eb0daaa = 11; // Numeric
const $60ff486a304db230$export$1bb1140fe1358b00 = 12; // Alphabetic
const $60ff486a304db230$export$f3e416a182673355 = 13; // Hebrew Letter
const $60ff486a304db230$export$8be180ec26319f9f = 14; // Ideographic
const $60ff486a304db230$export$70824c8942178d60 = 15; // Inseparable characters
const $60ff486a304db230$export$24aa617c849a894a = 16; // Hyphen
const $60ff486a304db230$export$a73c4d14459b698d = 17; // Break after
const $60ff486a304db230$export$921068d8846a1559 = 18; // Break before
const $60ff486a304db230$export$8b85a4f193482778 = 19; // Break on either side (but not pair)
const $60ff486a304db230$export$b2fd9c01d360241f = 20; // Zero-width space
const $60ff486a304db230$export$dcd191669c0a595f = 21; // Combining marks
const $60ff486a304db230$export$9e5d732f3676a9ba = 22; // Word joiner
const $60ff486a304db230$export$cb94397127ac9363 = 23; // Hangul LV
const $60ff486a304db230$export$746be9e3a3dfff1f = 24; // Hangul LVT
const $60ff486a304db230$export$96e3e682276c47cf = 25; // Hangul L Jamo
const $60ff486a304db230$export$fc2ff69ee2cb01bf = 26; // Hangul V Jamo
const $60ff486a304db230$export$8999624a7bae9d04 = 27; // Hangul T Jamo
const $60ff486a304db230$export$1dff41d5c0caca01 = 28; // Regional Indicator
const $60ff486a304db230$export$ddb7a6c76d9d93eb = 29; // Emoji Base
const $60ff486a304db230$export$7e93eb3105e4786d = 30; // Emoji Modifier
const $60ff486a304db230$export$30a74a373318dec6 = 31; // Zero Width Joiner
const $60ff486a304db230$export$54caeea5e6dab1f = 32; // Contingent break
const $60ff486a304db230$export$d710c5f50fc7496a = 33; // Ambiguous (Alphabetic or Ideograph)
const $60ff486a304db230$export$66498d28055820a9 = 34; // Break (mandatory)
const $60ff486a304db230$export$eb6c6d0b7c8826f2 = 35; // Conditional Japanese Starter
const $60ff486a304db230$export$de92be486109a1df = 36; // Carriage return
const $60ff486a304db230$export$606cfc2a8896c91f = 37; // Line feed
const $60ff486a304db230$export$e51d3c675bb0140d = 38; // Next line
const $60ff486a304db230$export$da51c6332ad11d7b = 39; // South-East Asian
const $60ff486a304db230$export$bea437c40441867d = 40; // Surrogates
const $60ff486a304db230$export$c4c7eecbfed13dc9 = 41; // Space
const $60ff486a304db230$export$98e1f8a379849661 = 42; // Unknown
const $1b6fba3281342923$export$98f50d781a474745 = 0; // Direct break opportunity
const $1b6fba3281342923$export$12ee1f8f5315ca7e = 1; // Indirect break opportunity
const $1b6fba3281342923$export$e4965ce242860454 = 2; // Indirect break opportunity for combining marks
const $1b6fba3281342923$export$8f14048969dcd45e = 3; // Prohibited break for combining marks
const $1b6fba3281342923$export$133eb141bf58aff4 = 4; // Prohibited break
const $1b6fba3281342923$export$5bdb8ccbf5c57afc = [
//OP , CL , CP , QU , GL , NS , EX , SY , IS , PR , PO , NU , AL , HL , ID , IN , HY , BA , BB , B2 , ZW , CM , WJ , H2 , H3 , JL , JV , JT , RI , EB , EM , ZWJ , CB
[
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$8f14048969dcd45e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
],
[
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$e4965ce242860454,
$1b6fba3281342923$export$133eb141bf58aff4,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$98f50d781a474745,
$1b6fba3281342923$export$12ee1f8f5315ca7e,
$1b6fba3281342923$export$98f50d781a474745
] // CB
];
const $f898ea50f3b38ab8$var$data = ($parcel$interopDefault($kQ2hT$base64js)).toByteArray("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");
const $f898ea50f3b38ab8$var$classTrie = new ($parcel$interopDefault($kQ2hT$unicodetrie))($f898ea50f3b38ab8$var$data);
const $f898ea50f3b38ab8$var$mapClass = function(c) {
switch(c){
case $60ff486a304db230$export$d710c5f50fc7496a:
return $60ff486a304db230$export$1bb1140fe1358b00;
case $60ff486a304db230$export$da51c6332ad11d7b:
case $60ff486a304db230$export$bea437c40441867d:
case $60ff486a304db230$export$98e1f8a379849661:
return $60ff486a304db230$export$1bb1140fe1358b00;
case $60ff486a304db230$export$eb6c6d0b7c8826f2:
return $60ff486a304db230$export$fb4028874a74450;
default:
return c;
}
};
const $f898ea50f3b38ab8$var$mapFirst = function(c) {
switch(c){
case $60ff486a304db230$export$606cfc2a8896c91f:
case $60ff486a304db230$export$e51d3c675bb0140d:
return $60ff486a304db230$export$66498d28055820a9;
case $60ff486a304db230$export$c4c7eecbfed13dc9:
return $60ff486a304db230$export$9e5d732f3676a9ba;
default:
return c;
}
};
class $f898ea50f3b38ab8$var$Break {
constructor(position, required = false){
this.position = position;
this.required = required;
}
}
class $f898ea50f3b38ab8$var$LineBreaker {
nextCodePoint() {
const code = this.string.charCodeAt(this.pos++);
const next = this.string.charCodeAt(this.pos);
// If a surrogate pair
if (0xd800 <= code && code <= 0xdbff && 0xdc00 <= next && next <= 0xdfff) {
this.pos++;
return (code - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
}
return code;
}
nextCharClass() {
return $f898ea50f3b38ab8$var$mapClass($f898ea50f3b38ab8$var$classTrie.get(this.nextCodePoint()));
}
getSimpleBreak() {
// handle classes not handled by the pair table
switch(this.nextClass){
case $60ff486a304db230$export$c4c7eecbfed13dc9:
return false;
case $60ff486a304db230$export$66498d28055820a9:
case $60ff486a304db230$export$606cfc2a8896c91f:
case $60ff486a304db230$export$e51d3c675bb0140d:
this.curClass = $60ff486a304db230$export$66498d28055820a9;
return false;
case $60ff486a304db230$export$de92be486109a1df:
this.curClass = $60ff486a304db230$export$de92be486109a1df;
return false;
}
return null;
}
getPairTableBreak(lastClass) {
// if not handled already, use the pair table
let shouldBreak = false;
switch($1b6fba3281342923$export$5bdb8ccbf5c57afc[this.curClass][this.nextClass]){
case $1b6fba3281342923$export$98f50d781a474745:
shouldBreak = true;
break;
case $1b6fba3281342923$export$12ee1f8f5315ca7e:
shouldBreak = lastClass === $60ff486a304db230$export$c4c7eecbfed13dc9;
break;
case $1b6fba3281342923$export$e4965ce242860454:
shouldBreak = lastClass === $60ff486a304db230$export$c4c7eecbfed13dc9;
if (!shouldBreak) {
shouldBreak = false;
return shouldBreak;
}
break;
case $1b6fba3281342923$export$8f14048969dcd45e:
if (lastClass !== $60ff486a304db230$export$c4c7eecbfed13dc9) return shouldBreak;
break;
case $1b6fba3281342923$export$133eb141bf58aff4:
break;
}
if (this.LB8a) shouldBreak = false;
// Rule LB21a
if (this.LB21a && (this.curClass === $60ff486a304db230$export$24aa617c849a894a || this.curClass === $60ff486a304db230$export$a73c4d14459b698d)) {
shouldBreak = false;
this.LB21a = false;
} else this.LB21a = this.curClass === $60ff486a304db230$export$f3e416a182673355;
// Rule LB30a
if (this.curClass === $60ff486a304db230$export$1dff41d5c0caca01) {
this.LB30a++;
if (this.LB30a == 2 && this.nextClass === $60ff486a304db230$export$1dff41d5c0caca01) {
shouldBreak = true;
this.LB30a = 0;
}
} else this.LB30a = 0;
this.curClass = this.nextClass;
return shouldBreak;
}
nextBreak() {
// get the first char if we're at the beginning of the string
if (this.curClass == null) {
let firstClass = this.nextCharClass();
this.curClass = $f898ea50f3b38ab8$var$mapFirst(firstClass);
this.nextClass = firstClass;
this.LB8a = firstClass === $60ff486a304db230$export$30a74a373318dec6;
this.LB30a = 0;
}
while(this.pos < this.string.length){
this.lastPos = this.pos;
const lastClass = this.nextClass;
this.nextClass = this.nextCharClass();
// explicit newline
if (this.curClass === $60ff486a304db230$export$66498d28055820a9 || this.curClass === $60ff486a304db230$export$de92be486109a1df && this.nextClass !== $60ff486a304db230$export$606cfc2a8896c91f) {
this.curClass = $f898ea50f3b38ab8$var$mapFirst($f898ea50f3b38ab8$var$mapClass(this.nextClass));
return new $f898ea50f3b38ab8$var$Break(this.lastPos, true);
}
let shouldBreak = this.getSimpleBreak();
if (shouldBreak === null) shouldBreak = this.getPairTableBreak(lastClass);
// Rule LB8a
this.LB8a = this.nextClass === $60ff486a304db230$export$30a74a373318dec6;
if (shouldBreak) return new $f898ea50f3b38ab8$var$Break(this.lastPos);
}
if (this.lastPos < this.string.length) {
this.lastPos = this.string.length;
return new $f898ea50f3b38ab8$var$Break(this.string.length);
}
return null;
}
constructor(string){
this.string = string;
this.pos = 0;
this.lastPos = 0;
this.curClass = null;
this.nextClass = null;
this.LB8a = false;
this.LB21a = false;
this.LB30a = 0;
}
}
module.exports = $f898ea50f3b38ab8$var$LineBreaker;
},{"base64-js":30,"unicode-trie":36}],30:[function(require,module,exports){
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
;(function (exports) {
'use strict';
var Arr = (typeof Uint8Array !== 'undefined')
? Uint8Array
: Array
var PLUS = '+'.charCodeAt(0)
var SLASH = '/'.charCodeAt(0)
var NUMBER = '0'.charCodeAt(0)
var LOWER = 'a'.charCodeAt(0)
var UPPER = 'A'.charCodeAt(0)
var PLUS_URL_SAFE = '-'.charCodeAt(0)
var SLASH_URL_SAFE = '_'.charCodeAt(0)
function decode (elt) {
var code = elt.charCodeAt(0)
if (code === PLUS ||
code === PLUS_URL_SAFE)
return 62 // '+'
if (code === SLASH ||
code === SLASH_URL_SAFE)
return 63 // '/'
if (code < NUMBER)
return -1 //no match
if (code < NUMBER + 10)
return code - NUMBER + 26 + 26
if (code < UPPER + 26)
return code - UPPER
if (code < LOWER + 26)
return code - LOWER + 26
}
function b64ToByteArray (b64) {
var i, j, l, tmp, placeHolders, arr
if (b64.length % 4 > 0) {
throw new Error('Invalid string. Length must be a multiple of 4')
}
// the number of equal signs (place holders)
// if there are two placeholders, than the two characters before it
// represent one byte
// if there is only one, then the three characters before it represent 2 bytes
// this is just a cheap hack to not do indexOf twice
var len = b64.length
placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
// base64 is 4/3 + up to two characters of the original data
arr = new Arr(b64.length * 3 / 4 - placeHolders)
// if there are placeholders, only get up to the last complete 4 chars
l = placeHolders > 0 ? b64.length - 4 : b64.length
var L = 0
function push (v) {
arr[L++] = v
}
for (i = 0, j = 0; i < l; i += 4, j += 3) {
tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
push((tmp & 0xFF0000) >> 16)
push((tmp & 0xFF00) >> 8)
push(tmp & 0xFF)
}
if (placeHolders === 2) {
tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
push(tmp & 0xFF)
} else if (placeHolders === 1) {
tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
push((tmp >> 8) & 0xFF)
push(tmp & 0xFF)
}
return arr
}
function uint8ToBase64 (uint8) {
var i,
extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
output = "",
temp, length
function encode (num) {
return lookup.charAt(num)
}
function tripletToBase64 (num) {
return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
}
// go through the array every three bytes, we'll deal with trailing stuff later
for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
output += tripletToBase64(temp)
}
// pad the end with zeros, but make sure to not forget the extra bytes
switch (extraBytes) {
case 1:
temp = uint8[uint8.length - 1]
output += encode(temp >> 2)
output += encode((temp << 4) & 0x3F)
output += '=='
break
case 2:
temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
output += encode(temp >> 10)
output += encode((temp >> 4) & 0x3F)
output += encode((temp << 2) & 0x3F)
output += '='
break
}
return output
}
exports.toByteArray = b64ToByteArray
exports.fromByteArray = uint8ToBase64
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
},{}],31:[function(require,module,exports){
'use strict';
var fflate = require('fflate');
const inflate = fflate.unzlib ;
class PNG {
static decode(path, fn) {
{
throw new Error('PNG.decode not available in browser build');
}
}
static load(path) {
{
throw new Error('PNG.load not available in browser build');
}
}
constructor(data) {
let i;
this.data = data;
this.pos = 8; // Skip the default header
this.palette = [];
this.imgData = [];
this.transparency = {};
this.text = {};
while (true) {
const chunkSize = this.readUInt32();
let section = '';
for (i = 0; i < 4; i++) {
section += String.fromCharCode(this.data[this.pos++]);
}
switch (section) {
case 'IHDR':
// we can grab interesting values from here (like width, height, etc)
this.width = this.readUInt32();
this.height = this.readUInt32();
this.bits = this.data[this.pos++];
this.colorType = this.data[this.pos++];
this.compressionMethod = this.data[this.pos++];
this.filterMethod = this.data[this.pos++];
this.interlaceMethod = this.data[this.pos++];
break;
case 'PLTE':
this.palette = this.read(chunkSize);
break;
case 'IDAT':
for (i = 0; i < chunkSize; i++) {
this.imgData.push(this.data[this.pos++]);
}
break;
case 'tRNS':
// This chunk can only occur once and it must occur after the
// PLTE chunk and before the IDAT chunk.
this.transparency = {};
switch (this.colorType) {
case 3:
// Indexed color, RGB. Each byte in this chunk is an alpha for
// the palette index in the PLTE ("palette") chunk up until the
// last non-opaque entry. Set up an array, stretching over all
// palette entries which will be 0 (opaque) or 1 (transparent).
this.transparency.indexed = this.read(chunkSize);
var short = 255 - this.transparency.indexed.length;
if (short > 0) {
for (i = 0; i < short; i++) {
this.transparency.indexed.push(255);
}
}
break;
case 0:
// Greyscale. Corresponding to entries in the PLTE chunk.
// Grey is two bytes, range 0 .. (2 ^ bit-depth) - 1
this.transparency.grayscale = this.read(chunkSize)[0];
break;
case 2:
// True color with proper alpha channel.
this.transparency.rgb = this.read(chunkSize);
break;
}
break;
case 'tEXt':
var text = this.read(chunkSize);
var index = text.indexOf(0);
var key = String.fromCharCode.apply(String, text.slice(0, index));
this.text[key] = String.fromCharCode.apply(
String,
text.slice(index + 1)
);
break;
case 'IEND':
// we've got everything we need!
switch (this.colorType) {
case 0:
case 3:
case 4:
this.colors = 1;
break;
case 2:
case 6:
this.colors = 3;
break;
}
this.hasAlphaChannel = [4, 6].includes(this.colorType);
var colors = this.colors + (this.hasAlphaChannel ? 1 : 0);
this.pixelBitlength = this.bits * colors;
switch (this.colors) {
case 1:
this.colorSpace = 'DeviceGray';
break;
case 3:
this.colorSpace = 'DeviceRGB';
break;
}
this.imgData = new Uint8Array(this.imgData);
return;
default:
// unknown (or unimportant) section, skip it
this.pos += chunkSize;
}
this.pos += 4; // Skip the CRC
if (this.pos > this.data.length) {
throw new Error('Incomplete or corrupt PNG file');
}
}
}
read(bytes) {
const result = new Array(bytes);
for (let i = 0; i < bytes; i++) {
result[i] = this.data[this.pos++];
}
return result;
}
readUInt32() {
const b1 = this.data[this.pos++] << 24;
const b2 = this.data[this.pos++] << 16;
const b3 = this.data[this.pos++] << 8;
const b4 = this.data[this.pos++];
return b1 | b2 | b3 | b4;
}
readUInt16() {
const b1 = this.data[this.pos++] << 8;
const b2 = this.data[this.pos++];
return b1 | b2;
}
decodePixels(fn) {
return inflate(new Uint8Array(this.imgData), (err, data) => {
if (err) {
throw err;
}
const { width, height } = this;
const pixelBytes = this.pixelBitlength / 8;
const pixels = new Uint8Array(width * height * pixelBytes);
const { length } = data;
let pos = 0;
function pass(x0, y0, dx, dy, singlePass = false) {
const w = Math.ceil((width - x0) / dx);
const h = Math.ceil((height - y0) / dy);
const scanlineLength = pixelBytes * w;
const buffer = singlePass ? pixels : new Uint8Array(scanlineLength * h);
let row = 0;
let c = 0;
while (row < h && pos < length) {
var byte, col, i, left, upper;
switch (data[pos++]) {
case 0: // None
for (i = 0; i < scanlineLength; i++) {
buffer[c++] = data[pos++];
}
break;
case 1: // Sub
for (i = 0; i < scanlineLength; i++) {
byte = data[pos++];
left = i < pixelBytes ? 0 : buffer[c - pixelBytes];
buffer[c++] = (byte + left) % 256;
}
break;
case 2: // Up
for (i = 0; i < scanlineLength; i++) {
byte = data[pos++];
col = (i - (i % pixelBytes)) / pixelBytes;
upper =
row &&
buffer[
(row - 1) * scanlineLength +
col * pixelBytes +
(i % pixelBytes)
];
buffer[c++] = (upper + byte) % 256;
}
break;
case 3: // Average
for (i = 0; i < scanlineLength; i++) {
byte = data[pos++];
col = (i - (i % pixelBytes)) / pixelBytes;
left = i < pixelBytes ? 0 : buffer[c - pixelBytes];
upper =
row &&
buffer[
(row - 1) * scanlineLength +
col * pixelBytes +
(i % pixelBytes)
];
buffer[c++] = (byte + Math.floor((left + upper) / 2)) % 256;
}
break;
case 4: // Paeth
for (i = 0; i < scanlineLength; i++) {
var paeth, upperLeft;
byte = data[pos++];
col = (i - (i % pixelBytes)) / pixelBytes;
left = i < pixelBytes ? 0 : buffer[c - pixelBytes];
if (row === 0) {
upper = upperLeft = 0;
} else {
upper =
buffer[
(row - 1) * scanlineLength +
col * pixelBytes +
(i % pixelBytes)
];
upperLeft =
col &&
buffer[
(row - 1) * scanlineLength +
(col - 1) * pixelBytes +
(i % pixelBytes)
];
}
const p = left + upper - upperLeft;
const pa = Math.abs(p - left);
const pb = Math.abs(p - upper);
const pc = Math.abs(p - upperLeft);
if (pa <= pb && pa <= pc) {
paeth = left;
} else if (pb <= pc) {
paeth = upper;
} else {
paeth = upperLeft;
}
buffer[c++] = (byte + paeth) % 256;
}
break;
default:
throw new Error(`Invalid filter algorithm: ${data[pos - 1]}`);
}
if (!singlePass) {
let pixelsPos = ((y0 + row * dy) * width + x0) * pixelBytes;
let bufferPos = row * scanlineLength;
for (i = 0; i < w; i++) {
for (let j = 0; j < pixelBytes; j++)
pixels[pixelsPos++] = buffer[bufferPos++];
pixelsPos += (dx - 1) * pixelBytes;
}
}
row++;
}
}
if (this.interlaceMethod === 1) {
/*
1 6 4 6 2 6 4 6
7 7 7 7 7 7 7 7
5 6 5 6 5 6 5 6
7 7 7 7 7 7 7 7
3 6 4 6 3 6 4 6
7 7 7 7 7 7 7 7
5 6 5 6 5 6 5 6
7 7 7 7 7 7 7 7
*/
pass(0, 0, 8, 8); // 1
pass(4, 0, 8, 8); // 2
pass(0, 4, 4, 8); // 3
pass(2, 0, 4, 4); // 4
pass(0, 2, 2, 4); // 5
pass(1, 0, 2, 2); // 6
pass(0, 1, 1, 2); // 7
} else {
pass(0, 0, 1, 1, true);
}
return fn(pixels);
});
}
decodePalette() {
const { palette } = this;
const { length } = palette;
const transparency = this.transparency.indexed || [];
const ret = new Uint8Array(transparency.length + length);
let pos = 0;
let c = 0;
for (let i = 0; i < length; i += 3) {
var left;
ret[pos++] = palette[i];
ret[pos++] = palette[i + 1];
ret[pos++] = palette[i + 2];
ret[pos++] = (left = transparency[c++]) != null ? left : 255;
}
return ret;
}
copyToImageData(imageData, pixels) {
let j, k;
let { colors } = this;
let palette = null;
let alpha = this.hasAlphaChannel;
if (this.palette.length) {
palette =
this._decodedPalette || (this._decodedPalette = this.decodePalette());
colors = 4;
alpha = true;
}
const data = imageData.data || imageData;
const { length } = data;
const input = palette || pixels;
let i = (j = 0);
if (colors === 1) {
while (i < length) {
k = palette ? pixels[i / 4] * 4 : j;
const v = input[k++];
data[i++] = v;
data[i++] = v;
data[i++] = v;
data[i++] = alpha ? input[k++] : 255;
j = k;
}
} else {
while (i < length) {
k = palette ? pixels[i / 4] * 4 : j;
data[i++] = input[k++];
data[i++] = input[k++];
data[i++] = input[k++];
data[i++] = alpha ? input[k++] : 255;
j = k;
}
}
}
decode(fn) {
const ret = new Uint8Array(this.width * this.height * 4);
return this.decodePixels(pixels => {
this.copyToImageData(ret, pixels);
return fn(ret);
});
}
}
module.exports = PNG;
},{"fflate":25}],32:[function(require,module,exports){
function $parcel$exportWildcard(dest, source) {
Object.keys(source).forEach(function(key) {
if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
return;
}
Object.defineProperty(dest, key, {
enumerable: true,
get: function get() {
return source[key];
}
});
});
return dest;
}
function $parcel$export(e, n, v, s) {
Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
}
$parcel$export(module.exports, "EncodeStream", () => $1ed46182c1410e1d$export$9b4f661deaa36c3e);
$parcel$export(module.exports, "DecodeStream", () => $8ae20583b93e4933$export$c18b354bac7948e9);
$parcel$export(module.exports, "Array", () => $8ea28a08eae2a116$export$c4be6576ca6fe4aa);
$parcel$export(module.exports, "LazyArray", () => $444f112d3cbc7e9f$export$5576c026028d4983);
$parcel$export(module.exports, "Bitfield", () => $3def237a34a226b5$export$96b43b8a49f688ea);
$parcel$export(module.exports, "Boolean", () => $8415e91bb83faf74$export$ff887cefee4d61ec);
$parcel$export(module.exports, "Buffer", () => $08d28604119af47e$export$7d22a0eea6656474);
$parcel$export(module.exports, "Enum", () => $070ce31ea947467f$export$deb82508dd66d288);
$parcel$export(module.exports, "Optional", () => $80703542fcfb6ff0$export$7acb7b24c478f9c6);
$parcel$export(module.exports, "Reserved", () => $f4fd49878232508a$export$da9b5fe187a9aa1);
$parcel$export(module.exports, "String", () => $d8705cd4022e7dcf$export$89b8e0fa65f6a914);
$parcel$export(module.exports, "Struct", () => $aa8b66bae6abe658$export$eabc71f011df675a);
$parcel$export(module.exports, "VersionedStruct", () => $fcb208a95f6d048b$export$95a8b60f4da7dec8);
// Node back-compat.
const $8ae20583b93e4933$var$ENCODING_MAPPING = {
utf16le: "utf-16le",
ucs2: "utf-16le",
utf16be: "utf-16be"
};
class $8ae20583b93e4933$export$c18b354bac7948e9 {
constructor(buffer){
this.buffer = buffer;
this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
this.pos = 0;
this.length = this.buffer.length;
}
readString(length, encoding = "ascii") {
encoding = $8ae20583b93e4933$var$ENCODING_MAPPING[encoding] || encoding;
let buf = this.readBuffer(length);
try {
let decoder = new TextDecoder(encoding);
return decoder.decode(buf);
} catch (err) {
return buf;
}
}
readBuffer(length) {
return this.buffer.slice(this.pos, this.pos += length);
}
readUInt24BE() {
return (this.readUInt16BE() << 8) + this.readUInt8();
}
readUInt24LE() {
return this.readUInt16LE() + (this.readUInt8() << 16);
}
readInt24BE() {
return (this.readInt16BE() << 8) + this.readUInt8();
}
readInt24LE() {
return this.readUInt16LE() + (this.readInt8() << 16);
}
}
$8ae20583b93e4933$export$c18b354bac7948e9.TYPES = {
UInt8: 1,
UInt16: 2,
UInt24: 3,
UInt32: 4,
Int8: 1,
Int16: 2,
Int24: 3,
Int32: 4,
Float: 4,
Double: 8
};
for (let key of Object.getOwnPropertyNames(DataView.prototype))if (key.slice(0, 3) === "get") {
let type = key.slice(3).replace("Ui", "UI");
if (type === "Float32") type = "Float";
else if (type === "Float64") type = "Double";
let bytes = $8ae20583b93e4933$export$c18b354bac7948e9.TYPES[type];
$8ae20583b93e4933$export$c18b354bac7948e9.prototype["read" + type + (bytes === 1 ? "" : "BE")] = function() {
const ret = this.view[key](this.pos, false);
this.pos += bytes;
return ret;
};
if (bytes !== 1) $8ae20583b93e4933$export$c18b354bac7948e9.prototype["read" + type + "LE"] = function() {
const ret = this.view[key](this.pos, true);
this.pos += bytes;
return ret;
};
}
const $1ed46182c1410e1d$var$textEncoder = new TextEncoder();
const $1ed46182c1410e1d$var$isBigEndian = new Uint8Array(new Uint16Array([
0x1234
]).buffer)[0] == 0x12;
class $1ed46182c1410e1d$export$9b4f661deaa36c3e {
constructor(buffer){
this.buffer = buffer;
this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
this.pos = 0;
}
writeBuffer(buffer) {
this.buffer.set(buffer, this.pos);
this.pos += buffer.length;
}
writeString(string, encoding = "ascii") {
let buf;
switch(encoding){
case "utf16le":
case "utf16-le":
case "ucs2":
buf = $1ed46182c1410e1d$var$stringToUtf16(string, $1ed46182c1410e1d$var$isBigEndian);
break;
case "utf16be":
case "utf16-be":
buf = $1ed46182c1410e1d$var$stringToUtf16(string, !$1ed46182c1410e1d$var$isBigEndian);
break;
case "utf8":
buf = $1ed46182c1410e1d$var$textEncoder.encode(string);
break;
case "ascii":
buf = $1ed46182c1410e1d$var$stringToAscii(string);
break;
default:
throw new Error(`Unsupported encoding: ${encoding}`);
}
this.writeBuffer(buf);
}
writeUInt24BE(val) {
this.buffer[this.pos++] = val >>> 16 & 0xff;
this.buffer[this.pos++] = val >>> 8 & 0xff;
this.buffer[this.pos++] = val & 0xff;
}
writeUInt24LE(val) {
this.buffer[this.pos++] = val & 0xff;
this.buffer[this.pos++] = val >>> 8 & 0xff;
this.buffer[this.pos++] = val >>> 16 & 0xff;
}
writeInt24BE(val) {
if (val >= 0) this.writeUInt24BE(val);
else this.writeUInt24BE(val + 0xffffff + 1);
}
writeInt24LE(val) {
if (val >= 0) this.writeUInt24LE(val);
else this.writeUInt24LE(val + 0xffffff + 1);
}
fill(val, length) {
if (length < this.buffer.length) {
this.buffer.fill(val, this.pos, this.pos + length);
this.pos += length;
} else {
const buf = new Uint8Array(length);
buf.fill(val);
this.writeBuffer(buf);
}
}
}
function $1ed46182c1410e1d$var$stringToUtf16(string, swap) {
let buf = new Uint16Array(string.length);
for(let i = 0; i < string.length; i++){
let code = string.charCodeAt(i);
if (swap) code = code >> 8 | (code & 0xff) << 8;
buf[i] = code;
}
return new Uint8Array(buf.buffer);
}
function $1ed46182c1410e1d$var$stringToAscii(string) {
let buf = new Uint8Array(string.length);
for(let i = 0; i < string.length; i++)// Match node.js behavior - encoding allows 8-bit rather than 7-bit.
buf[i] = string.charCodeAt(i);
return buf;
}
for (let key of Object.getOwnPropertyNames(DataView.prototype))if (key.slice(0, 3) === "set") {
let type = key.slice(3).replace("Ui", "UI");
if (type === "Float32") type = "Float";
else if (type === "Float64") type = "Double";
let bytes = (0, $8ae20583b93e4933$export$c18b354bac7948e9).TYPES[type];
$1ed46182c1410e1d$export$9b4f661deaa36c3e.prototype["write" + type + (bytes === 1 ? "" : "BE")] = function(value) {
this.view[key](this.pos, value, false);
this.pos += bytes;
};
if (bytes !== 1) $1ed46182c1410e1d$export$9b4f661deaa36c3e.prototype["write" + type + "LE"] = function(value) {
this.view[key](this.pos, value, true);
this.pos += bytes;
};
}
class $8d21f7fa58802901$export$ef88aa0d34c34520 {
fromBuffer(buffer) {
let stream = new (0, $8ae20583b93e4933$export$c18b354bac7948e9)(buffer);
return this.decode(stream);
}
toBuffer(value) {
let size = this.size(value);
let buffer = new Uint8Array(size);
let stream = new (0, $1ed46182c1410e1d$export$9b4f661deaa36c3e)(buffer);
this.encode(stream, value);
return buffer;
}
}
var $af65abf7bf65ac42$exports = {};
$parcel$export($af65abf7bf65ac42$exports, "Number", () => $af65abf7bf65ac42$export$fffa67e515d04022);
$parcel$export($af65abf7bf65ac42$exports, "uint8", () => $af65abf7bf65ac42$export$52e103c63c4e68cf);
$parcel$export($af65abf7bf65ac42$exports, "uint16be", () => $af65abf7bf65ac42$export$60dfe43c8297a8f8);
$parcel$export($af65abf7bf65ac42$exports, "uint16", () => $af65abf7bf65ac42$export$56bd24b5a3ee8456);
$parcel$export($af65abf7bf65ac42$exports, "uint16le", () => $af65abf7bf65ac42$export$b92d76f0ca6d1789);
$parcel$export($af65abf7bf65ac42$exports, "uint24be", () => $af65abf7bf65ac42$export$255f45171f96b50c);
$parcel$export($af65abf7bf65ac42$exports, "uint24", () => $af65abf7bf65ac42$export$1925298fbd719b21);
$parcel$export($af65abf7bf65ac42$exports, "uint24le", () => $af65abf7bf65ac42$export$758e1dafc8dc7271);
$parcel$export($af65abf7bf65ac42$exports, "uint32be", () => $af65abf7bf65ac42$export$74c16dba6c885532);
$parcel$export($af65abf7bf65ac42$exports, "uint32", () => $af65abf7bf65ac42$export$de9ffb9418dd7d0d);
$parcel$export($af65abf7bf65ac42$exports, "uint32le", () => $af65abf7bf65ac42$export$5f744bb30a534bc9);
$parcel$export($af65abf7bf65ac42$exports, "int8", () => $af65abf7bf65ac42$export$5984f25eab09961f);
$parcel$export($af65abf7bf65ac42$exports, "int16be", () => $af65abf7bf65ac42$export$198ae7d10d26a900);
$parcel$export($af65abf7bf65ac42$exports, "int16", () => $af65abf7bf65ac42$export$c35c15c7caeff2b6);
$parcel$export($af65abf7bf65ac42$exports, "int16le", () => $af65abf7bf65ac42$export$399cc4b7169e5aed);
$parcel$export($af65abf7bf65ac42$exports, "int24be", () => $af65abf7bf65ac42$export$3676d1f71eca2ec0);
$parcel$export($af65abf7bf65ac42$exports, "int24", () => $af65abf7bf65ac42$export$73f695d681ac61f9);
$parcel$export($af65abf7bf65ac42$exports, "int24le", () => $af65abf7bf65ac42$export$671f8672dbd40a4);
$parcel$export($af65abf7bf65ac42$exports, "int32be", () => $af65abf7bf65ac42$export$78a2ac3d09dd42d5);
$parcel$export($af65abf7bf65ac42$exports, "int32", () => $af65abf7bf65ac42$export$1d95835383bb05a);
$parcel$export($af65abf7bf65ac42$exports, "int32le", () => $af65abf7bf65ac42$export$5ec1f146e759329a);
$parcel$export($af65abf7bf65ac42$exports, "floatbe", () => $af65abf7bf65ac42$export$92b5c14c6abb5c97);
$parcel$export($af65abf7bf65ac42$exports, "float", () => $af65abf7bf65ac42$export$6b5cd3983e3ee5ab);
$parcel$export($af65abf7bf65ac42$exports, "floatle", () => $af65abf7bf65ac42$export$6d20592bc4cb19d9);
$parcel$export($af65abf7bf65ac42$exports, "doublebe", () => $af65abf7bf65ac42$export$e50b9e97e4d43631);
$parcel$export($af65abf7bf65ac42$exports, "double", () => $af65abf7bf65ac42$export$7b3cbda67be88f5f);
$parcel$export($af65abf7bf65ac42$exports, "doublele", () => $af65abf7bf65ac42$export$6f53315aa512b751);
$parcel$export($af65abf7bf65ac42$exports, "Fixed", () => $af65abf7bf65ac42$export$13475bbd2a37a9b4);
$parcel$export($af65abf7bf65ac42$exports, "fixed16be", () => $af65abf7bf65ac42$export$f87b441e6bd90278);
$parcel$export($af65abf7bf65ac42$exports, "fixed16", () => $af65abf7bf65ac42$export$a3abada75ef55921);
$parcel$export($af65abf7bf65ac42$exports, "fixed16le", () => $af65abf7bf65ac42$export$3752a2886837dc22);
$parcel$export($af65abf7bf65ac42$exports, "fixed32be", () => $af65abf7bf65ac42$export$dd71d8d9bc792632);
$parcel$export($af65abf7bf65ac42$exports, "fixed32", () => $af65abf7bf65ac42$export$e913265d48471f2d);
$parcel$export($af65abf7bf65ac42$exports, "fixed32le", () => $af65abf7bf65ac42$export$7fc47db6a5fc8223);
class $af65abf7bf65ac42$export$fffa67e515d04022 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, endian = "BE"){
super();
this.type = type;
this.endian = endian;
this.fn = this.type;
if (this.type[this.type.length - 1] !== "8") this.fn += this.endian;
}
size() {
return (0, $8ae20583b93e4933$export$c18b354bac7948e9).TYPES[this.type];
}
decode(stream) {
return stream[`read${this.fn}`]();
}
encode(stream, val) {
return stream[`write${this.fn}`](val);
}
}
const $af65abf7bf65ac42$export$52e103c63c4e68cf = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt8");
const $af65abf7bf65ac42$export$60dfe43c8297a8f8 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt16", "BE");
const $af65abf7bf65ac42$export$56bd24b5a3ee8456 = $af65abf7bf65ac42$export$60dfe43c8297a8f8;
const $af65abf7bf65ac42$export$b92d76f0ca6d1789 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt16", "LE");
const $af65abf7bf65ac42$export$255f45171f96b50c = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt24", "BE");
const $af65abf7bf65ac42$export$1925298fbd719b21 = $af65abf7bf65ac42$export$255f45171f96b50c;
const $af65abf7bf65ac42$export$758e1dafc8dc7271 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt24", "LE");
const $af65abf7bf65ac42$export$74c16dba6c885532 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt32", "BE");
const $af65abf7bf65ac42$export$de9ffb9418dd7d0d = $af65abf7bf65ac42$export$74c16dba6c885532;
const $af65abf7bf65ac42$export$5f744bb30a534bc9 = new $af65abf7bf65ac42$export$fffa67e515d04022("UInt32", "LE");
const $af65abf7bf65ac42$export$5984f25eab09961f = new $af65abf7bf65ac42$export$fffa67e515d04022("Int8");
const $af65abf7bf65ac42$export$198ae7d10d26a900 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int16", "BE");
const $af65abf7bf65ac42$export$c35c15c7caeff2b6 = $af65abf7bf65ac42$export$198ae7d10d26a900;
const $af65abf7bf65ac42$export$399cc4b7169e5aed = new $af65abf7bf65ac42$export$fffa67e515d04022("Int16", "LE");
const $af65abf7bf65ac42$export$3676d1f71eca2ec0 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int24", "BE");
const $af65abf7bf65ac42$export$73f695d681ac61f9 = $af65abf7bf65ac42$export$3676d1f71eca2ec0;
const $af65abf7bf65ac42$export$671f8672dbd40a4 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int24", "LE");
const $af65abf7bf65ac42$export$78a2ac3d09dd42d5 = new $af65abf7bf65ac42$export$fffa67e515d04022("Int32", "BE");
const $af65abf7bf65ac42$export$1d95835383bb05a = $af65abf7bf65ac42$export$78a2ac3d09dd42d5;
const $af65abf7bf65ac42$export$5ec1f146e759329a = new $af65abf7bf65ac42$export$fffa67e515d04022("Int32", "LE");
const $af65abf7bf65ac42$export$92b5c14c6abb5c97 = new $af65abf7bf65ac42$export$fffa67e515d04022("Float", "BE");
const $af65abf7bf65ac42$export$6b5cd3983e3ee5ab = $af65abf7bf65ac42$export$92b5c14c6abb5c97;
const $af65abf7bf65ac42$export$6d20592bc4cb19d9 = new $af65abf7bf65ac42$export$fffa67e515d04022("Float", "LE");
const $af65abf7bf65ac42$export$e50b9e97e4d43631 = new $af65abf7bf65ac42$export$fffa67e515d04022("Double", "BE");
const $af65abf7bf65ac42$export$7b3cbda67be88f5f = $af65abf7bf65ac42$export$e50b9e97e4d43631;
const $af65abf7bf65ac42$export$6f53315aa512b751 = new $af65abf7bf65ac42$export$fffa67e515d04022("Double", "LE");
class $af65abf7bf65ac42$export$13475bbd2a37a9b4 extends $af65abf7bf65ac42$export$fffa67e515d04022 {
constructor(size, endian, fracBits = size >> 1){
super(`Int${size}`, endian);
this._point = 1 << fracBits;
}
decode(stream) {
return super.decode(stream) / this._point;
}
encode(stream, val) {
return super.encode(stream, val * this._point | 0);
}
}
const $af65abf7bf65ac42$export$f87b441e6bd90278 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(16, "BE");
const $af65abf7bf65ac42$export$a3abada75ef55921 = $af65abf7bf65ac42$export$f87b441e6bd90278;
const $af65abf7bf65ac42$export$3752a2886837dc22 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(16, "LE");
const $af65abf7bf65ac42$export$dd71d8d9bc792632 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(32, "BE");
const $af65abf7bf65ac42$export$e913265d48471f2d = $af65abf7bf65ac42$export$dd71d8d9bc792632;
const $af65abf7bf65ac42$export$7fc47db6a5fc8223 = new $af65abf7bf65ac42$export$13475bbd2a37a9b4(32, "LE");
var $4559ecf940edc78d$exports = {};
$parcel$export($4559ecf940edc78d$exports, "resolveLength", () => $4559ecf940edc78d$export$83b6dc3503c1fda6);
$parcel$export($4559ecf940edc78d$exports, "PropertyDescriptor", () => $4559ecf940edc78d$export$41705b1d644e0f14);
function $4559ecf940edc78d$export$83b6dc3503c1fda6(length, stream, parent) {
let res;
if (typeof length === "number") res = length;
else if (typeof length === "function") res = length.call(parent, parent);
else if (parent && typeof length === "string") res = parent[length];
else if (stream && length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) res = length.decode(stream);
if (isNaN(res)) throw new Error("Not a fixed size");
return res;
}
class $4559ecf940edc78d$export$41705b1d644e0f14 {
constructor(opts = {}){
this.enumerable = true;
this.configurable = true;
for(let key in opts){
const val = opts[key];
this[key] = val;
}
}
}
class $8ea28a08eae2a116$export$c4be6576ca6fe4aa extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, length, lengthType = "count"){
super();
this.type = type;
this.length = length;
this.lengthType = lengthType;
}
decode(stream, parent) {
let length;
const { pos: pos } = stream;
const res = [];
let ctx = parent;
if (this.length != null) length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
// define hidden properties
Object.defineProperties(res, {
parent: {
value: parent
},
_startOffset: {
value: pos
},
_currentOffset: {
value: 0,
writable: true
},
_length: {
value: length
}
});
ctx = res;
}
if (length == null || this.lengthType === "bytes") {
const target = length != null ? stream.pos + length : (parent != null ? parent._length : undefined) ? parent._startOffset + parent._length : stream.length;
while(stream.pos < target)res.push(this.type.decode(stream, ctx));
} else for(let i = 0, end = length; i < end; i++)res.push(this.type.decode(stream, ctx));
return res;
}
size(array, ctx, includePointers = true) {
if (!array) return this.type.size(null, ctx) * $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, null, ctx);
let size = 0;
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
size += this.length.size();
ctx = {
parent: ctx,
pointerSize: 0
};
}
for (let item of array)size += this.type.size(item, ctx);
if (ctx && includePointers && this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) size += ctx.pointerSize;
return size;
}
encode(stream, array, parent) {
let ctx = parent;
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
ctx = {
pointers: [],
startOffset: stream.pos,
parent: parent
};
ctx.pointerOffset = stream.pos + this.size(array, ctx, false);
this.length.encode(stream, array.length);
}
for (let item of array)this.type.encode(stream, item, ctx);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) {
let i = 0;
while(i < ctx.pointers.length){
const ptr = ctx.pointers[i++];
ptr.type.encode(stream, ptr.val, ptr.parent);
}
}
}
}
class $444f112d3cbc7e9f$export$5576c026028d4983 extends (0, $8ea28a08eae2a116$export$c4be6576ca6fe4aa) {
decode(stream, parent) {
const { pos: pos } = stream;
const length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) parent = {
parent: parent,
_startOffset: pos,
_currentOffset: 0,
_length: length
};
const res = new $444f112d3cbc7e9f$var$LazyArrayValue(this.type, length, stream, parent);
stream.pos += length * this.type.size(null, parent);
return res;
}
size(val, ctx) {
if (val instanceof $444f112d3cbc7e9f$var$LazyArrayValue) val = val.toArray();
return super.size(val, ctx);
}
encode(stream, val, ctx) {
if (val instanceof $444f112d3cbc7e9f$var$LazyArrayValue) val = val.toArray();
return super.encode(stream, val, ctx);
}
}
class $444f112d3cbc7e9f$var$LazyArrayValue {
constructor(type, length, stream, ctx){
this.type = type;
this.length = length;
this.stream = stream;
this.ctx = ctx;
this.base = this.stream.pos;
this.items = [];
}
get(index) {
if (index < 0 || index >= this.length) return undefined;
if (this.items[index] == null) {
const { pos: pos } = this.stream;
this.stream.pos = this.base + this.type.size(null, this.ctx) * index;
this.items[index] = this.type.decode(this.stream, this.ctx);
this.stream.pos = pos;
}
return this.items[index];
}
toArray() {
const result = [];
for(let i = 0, end = this.length; i < end; i++)result.push(this.get(i));
return result;
}
}
class $3def237a34a226b5$export$96b43b8a49f688ea extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, flags = []){
super();
this.type = type;
this.flags = flags;
}
decode(stream) {
const val = this.type.decode(stream);
const res = {};
for(let i = 0; i < this.flags.length; i++){
const flag = this.flags[i];
if (flag != null) res[flag] = !!(val & 1 << i);
}
return res;
}
size() {
return this.type.size();
}
encode(stream, keys) {
let val = 0;
for(let i = 0; i < this.flags.length; i++){
const flag = this.flags[i];
if (flag != null) {
if (keys[flag]) val |= 1 << i;
}
}
return this.type.encode(stream, val);
}
}
class $8415e91bb83faf74$export$ff887cefee4d61ec extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type){
super();
this.type = type;
}
decode(stream, parent) {
return !!this.type.decode(stream, parent);
}
size(val, parent) {
return this.type.size(val, parent);
}
encode(stream, val, parent) {
return this.type.encode(stream, +val, parent);
}
}
class $08d28604119af47e$export$7d22a0eea6656474 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(length){
super();
this.length = length;
}
decode(stream, parent) {
const length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
return stream.readBuffer(length);
}
size(val, parent) {
if (!val) return $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, null, parent);
let len = val.length;
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) len += this.length.size();
return len;
}
encode(stream, buf, parent) {
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) this.length.encode(stream, buf.length);
return stream.writeBuffer(buf);
}
}
class $070ce31ea947467f$export$deb82508dd66d288 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, options = []){
super();
this.type = type;
this.options = options;
}
decode(stream) {
const index = this.type.decode(stream);
return this.options[index] || index;
}
size() {
return this.type.size();
}
encode(stream, val) {
const index = this.options.indexOf(val);
if (index === -1) throw new Error(`Unknown option in enum: ${val}`);
return this.type.encode(stream, index);
}
}
class $80703542fcfb6ff0$export$7acb7b24c478f9c6 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, condition = true){
super();
this.type = type;
this.condition = condition;
}
decode(stream, parent) {
let { condition: condition } = this;
if (typeof condition === "function") condition = condition.call(parent, parent);
if (condition) return this.type.decode(stream, parent);
}
size(val, parent) {
let { condition: condition } = this;
if (typeof condition === "function") condition = condition.call(parent, parent);
if (condition) return this.type.size(val, parent);
else return 0;
}
encode(stream, val, parent) {
let { condition: condition } = this;
if (typeof condition === "function") condition = condition.call(parent, parent);
if (condition) return this.type.encode(stream, val, parent);
}
}
class $f4fd49878232508a$export$da9b5fe187a9aa1 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(type, count = 1){
super();
this.type = type;
this.count = count;
}
decode(stream, parent) {
stream.pos += this.size(null, parent);
return undefined;
}
size(data, parent) {
const count = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.count, null, parent);
return this.type.size() * count;
}
encode(stream, val, parent) {
return stream.fill(0, this.size(val, parent));
}
}
class $d8705cd4022e7dcf$export$89b8e0fa65f6a914 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(length, encoding = "ascii"){
super();
this.length = length;
this.encoding = encoding;
}
decode(stream, parent) {
let length, pos;
let { encoding: encoding } = this;
if (typeof encoding === "function") encoding = encoding.call(parent, parent) || "ascii";
let width = $d8705cd4022e7dcf$var$encodingWidth(encoding);
if (this.length != null) length = $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, stream, parent);
else {
let buffer;
({ buffer: buffer, length: length, pos: pos } = stream);
while(pos < length - width + 1 && (buffer[pos] !== 0x00 || width === 2 && buffer[pos + 1] !== 0x00))pos += width;
length = pos - stream.pos;
}
const string = stream.readString(length, encoding);
if (this.length == null && stream.pos < stream.length) stream.pos += width;
return string;
}
size(val, parent) {
// Use the defined value if no value was given
if (val === undefined || val === null) return $4559ecf940edc78d$export$83b6dc3503c1fda6(this.length, null, parent);
let { encoding: encoding } = this;
if (typeof encoding === "function") encoding = encoding.call(parent != null ? parent.val : undefined, parent != null ? parent.val : undefined) || "ascii";
if (encoding === "utf16be") encoding = "utf16le";
let size = $d8705cd4022e7dcf$var$byteLength(val, encoding);
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) size += this.length.size();
if (this.length == null) size += $d8705cd4022e7dcf$var$encodingWidth(encoding);
return size;
}
encode(stream, val, parent) {
let { encoding: encoding } = this;
if (typeof encoding === "function") encoding = encoding.call(parent != null ? parent.val : undefined, parent != null ? parent.val : undefined) || "ascii";
if (this.length instanceof (0, $af65abf7bf65ac42$export$fffa67e515d04022)) this.length.encode(stream, $d8705cd4022e7dcf$var$byteLength(val, encoding));
stream.writeString(val, encoding);
if (this.length == null) return $d8705cd4022e7dcf$var$encodingWidth(encoding) == 2 ? stream.writeUInt16LE(0x0000) : stream.writeUInt8(0x00);
}
}
function $d8705cd4022e7dcf$var$encodingWidth(encoding) {
switch(encoding){
case "ascii":
case "utf8":
return 1;
case "utf16le":
case "utf16-le":
case "utf-16be":
case "utf-16le":
case "utf16be":
case "utf16-be":
case "ucs2":
return 2;
default:
//TODO: assume all other encodings are 1-byters
//throw new Error('Unknown encoding ' + encoding);
return 1;
}
}
function $d8705cd4022e7dcf$var$byteLength(string, encoding) {
switch(encoding){
case "ascii":
return string.length;
case "utf8":
let len = 0;
for(let i = 0; i < string.length; i++){
let c = string.charCodeAt(i);
if (c >= 0xd800 && c <= 0xdbff && i < string.length - 1) {
let c2 = string.charCodeAt(++i);
if ((c2 & 0xfc00) === 0xdc00) c = ((c & 0x3ff) << 10) + (c2 & 0x3ff) + 0x10000;
else // unmatched surrogate.
i--;
}
if ((c & 0xffffff80) === 0) len++;
else if ((c & 0xfffff800) === 0) len += 2;
else if ((c & 0xffff0000) === 0) len += 3;
else if ((c & 0xffe00000) === 0) len += 4;
}
return len;
case "utf16le":
case "utf16-le":
case "utf16be":
case "utf16-be":
case "ucs2":
return string.length * 2;
default:
throw new Error("Unknown encoding " + encoding);
}
}
class $aa8b66bae6abe658$export$eabc71f011df675a extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(fields = {}){
super();
this.fields = fields;
}
decode(stream, parent, length = 0) {
const res = this._setup(stream, parent, length);
this._parseFields(stream, res, this.fields);
if (this.process != null) this.process.call(res, stream);
return res;
}
_setup(stream, parent, length) {
const res = {};
// define hidden properties
Object.defineProperties(res, {
parent: {
value: parent
},
_startOffset: {
value: stream.pos
},
_currentOffset: {
value: 0,
writable: true
},
_length: {
value: length
}
});
return res;
}
_parseFields(stream, res, fields) {
for(let key in fields){
var val;
const type = fields[key];
if (typeof type === "function") val = type.call(res, res);
else val = type.decode(stream, res);
if (val !== undefined) {
if (val instanceof $4559ecf940edc78d$export$41705b1d644e0f14) Object.defineProperty(res, key, val);
else res[key] = val;
}
res._currentOffset = stream.pos - res._startOffset;
}
}
size(val, parent, includePointers = true) {
if (val == null) val = {};
const ctx = {
parent: parent,
val: val,
pointerSize: 0
};
if (this.preEncode != null) this.preEncode.call(val);
let size = 0;
for(let key in this.fields){
const type = this.fields[key];
if (type.size != null) size += type.size(val[key], ctx);
}
if (includePointers) size += ctx.pointerSize;
return size;
}
encode(stream, val, parent) {
let type;
if (this.preEncode != null) this.preEncode.call(val, stream);
const ctx = {
pointers: [],
startOffset: stream.pos,
parent: parent,
val: val,
pointerSize: 0
};
ctx.pointerOffset = stream.pos + this.size(val, ctx, false);
for(let key in this.fields){
type = this.fields[key];
if (type.encode != null) type.encode(stream, val[key], ctx);
}
let i = 0;
while(i < ctx.pointers.length){
const ptr = ctx.pointers[i++];
ptr.type.encode(stream, ptr.val, ptr.parent);
}
}
}
const $fcb208a95f6d048b$var$getPath = (object, pathArray)=>{
return pathArray.reduce((prevObj, key)=>prevObj && prevObj[key], object);
};
class $fcb208a95f6d048b$export$95a8b60f4da7dec8 extends (0, $aa8b66bae6abe658$export$eabc71f011df675a) {
constructor(type, versions = {}){
super();
this.type = type;
this.versions = versions;
if (typeof type === "string") this.versionPath = type.split(".");
}
decode(stream, parent, length = 0) {
const res = this._setup(stream, parent, length);
if (typeof this.type === "string") res.version = $fcb208a95f6d048b$var$getPath(parent, this.versionPath);
else res.version = this.type.decode(stream);
if (this.versions.header) this._parseFields(stream, res, this.versions.header);
const fields = this.versions[res.version];
if (fields == null) throw new Error(`Unknown version ${res.version}`);
if (fields instanceof $fcb208a95f6d048b$export$95a8b60f4da7dec8) return fields.decode(stream, parent);
this._parseFields(stream, res, fields);
if (this.process != null) this.process.call(res, stream);
return res;
}
size(val, parent, includePointers = true) {
let key, type;
if (!val) throw new Error("Not a fixed size");
if (this.preEncode != null) this.preEncode.call(val);
const ctx = {
parent: parent,
val: val,
pointerSize: 0
};
let size = 0;
if (typeof this.type !== "string") size += this.type.size(val.version, ctx);
if (this.versions.header) for(key in this.versions.header){
type = this.versions.header[key];
if (type.size != null) size += type.size(val[key], ctx);
}
const fields = this.versions[val.version];
if (fields == null) throw new Error(`Unknown version ${val.version}`);
for(key in fields){
type = fields[key];
if (type.size != null) size += type.size(val[key], ctx);
}
if (includePointers) size += ctx.pointerSize;
return size;
}
encode(stream, val, parent) {
let key, type;
if (this.preEncode != null) this.preEncode.call(val, stream);
const ctx = {
pointers: [],
startOffset: stream.pos,
parent: parent,
val: val,
pointerSize: 0
};
ctx.pointerOffset = stream.pos + this.size(val, ctx, false);
if (typeof this.type !== "string") this.type.encode(stream, val.version);
if (this.versions.header) for(key in this.versions.header){
type = this.versions.header[key];
if (type.encode != null) type.encode(stream, val[key], ctx);
}
const fields = this.versions[val.version];
for(key in fields){
type = fields[key];
if (type.encode != null) type.encode(stream, val[key], ctx);
}
let i = 0;
while(i < ctx.pointers.length){
const ptr = ctx.pointers[i++];
ptr.type.encode(stream, ptr.val, ptr.parent);
}
}
}
var $92184962f8f0d5e2$exports = {};
$parcel$export($92184962f8f0d5e2$exports, "Pointer", () => $92184962f8f0d5e2$export$b56007f12edf0c17);
$parcel$export($92184962f8f0d5e2$exports, "VoidPointer", () => $92184962f8f0d5e2$export$df5cb1f3d04f5a0f);
class $92184962f8f0d5e2$export$b56007f12edf0c17 extends (0, $8d21f7fa58802901$export$ef88aa0d34c34520) {
constructor(offsetType, type, options = {}){
super();
this.offsetType = offsetType;
this.type = type;
this.options = options;
if (this.type === "void") this.type = null;
if (this.options.type == null) this.options.type = "local";
if (this.options.allowNull == null) this.options.allowNull = true;
if (this.options.nullValue == null) this.options.nullValue = 0;
if (this.options.lazy == null) this.options.lazy = false;
if (this.options.relativeTo) {
if (typeof this.options.relativeTo !== "function") throw new Error("relativeTo option must be a function");
this.relativeToGetter = options.relativeTo;
}
}
decode(stream, ctx) {
const offset = this.offsetType.decode(stream, ctx);
// handle NULL pointers
if (offset === this.options.nullValue && this.options.allowNull) return null;
let relative;
switch(this.options.type){
case "local":
relative = ctx._startOffset;
break;
case "immediate":
relative = stream.pos - this.offsetType.size();
break;
case "parent":
relative = ctx.parent._startOffset;
break;
default:
var c = ctx;
while(c.parent)c = c.parent;
relative = c._startOffset || 0;
}
if (this.options.relativeTo) relative += this.relativeToGetter(ctx);
const ptr = offset + relative;
if (this.type != null) {
let val = null;
const decodeValue = ()=>{
if (val != null) return val;
const { pos: pos } = stream;
stream.pos = ptr;
val = this.type.decode(stream, ctx);
stream.pos = pos;
return val;
};
// If this is a lazy pointer, define a getter to decode only when needed.
// This obviously only works when the pointer is contained by a Struct.
if (this.options.lazy) return new $4559ecf940edc78d$export$41705b1d644e0f14({
get: decodeValue
});
return decodeValue();
} else return ptr;
}
size(val, ctx) {
const parent = ctx;
switch(this.options.type){
case "local":
case "immediate":
break;
case "parent":
ctx = ctx.parent;
break;
default:
while(ctx.parent)ctx = ctx.parent;
}
let { type: type } = this;
if (type == null) {
if (!(val instanceof $92184962f8f0d5e2$export$df5cb1f3d04f5a0f)) throw new Error("Must be a VoidPointer");
({ type: type } = val);
val = val.value;
}
if (val && ctx) {
// Must be written as two separate lines rather than += in case `type.size` mutates ctx.pointerSize.
let size = type.size(val, parent);
ctx.pointerSize += size;
}
return this.offsetType.size();
}
encode(stream, val, ctx) {
let relative;
const parent = ctx;
if (val == null) {
this.offsetType.encode(stream, this.options.nullValue);
return;
}
switch(this.options.type){
case "local":
relative = ctx.startOffset;
break;
case "immediate":
relative = stream.pos + this.offsetType.size(val, parent);
break;
case "parent":
ctx = ctx.parent;
relative = ctx.startOffset;
break;
default:
relative = 0;
while(ctx.parent)ctx = ctx.parent;
}
if (this.options.relativeTo) relative += this.relativeToGetter(parent.val);
this.offsetType.encode(stream, ctx.pointerOffset - relative);
let { type: type } = this;
if (type == null) {
if (!(val instanceof $92184962f8f0d5e2$export$df5cb1f3d04f5a0f)) throw new Error("Must be a VoidPointer");
({ type: type } = val);
val = val.value;
}
ctx.pointers.push({
type: type,
val: val,
parent: parent
});
return ctx.pointerOffset += type.size(val, parent);
}
}
class $92184962f8f0d5e2$export$df5cb1f3d04f5a0f {
constructor(type, value){
this.type = type;
this.value = value;
}
}
$parcel$exportWildcard(module.exports, $4559ecf940edc78d$exports);
$parcel$exportWildcard(module.exports, $af65abf7bf65ac42$exports);
$parcel$exportWildcard(module.exports, $92184962f8f0d5e2$exports);
},{}],33:[function(require,module,exports){
var TINF_OK = 0;
var TINF_DATA_ERROR = -3;
function Tree() {
this.table = new Uint16Array(16); /* table of code length counts */
this.trans = new Uint16Array(288); /* code -> symbol translation table */
}
function Data(source, dest) {
this.source = source;
this.sourceIndex = 0;
this.tag = 0;
this.bitcount = 0;
this.dest = dest;
this.destLen = 0;
this.ltree = new Tree(); /* dynamic length/symbol tree */
this.dtree = new Tree(); /* dynamic distance tree */
}
/* --------------------------------------------------- *
* -- uninitialized global data (static structures) -- *
* --------------------------------------------------- */
var sltree = new Tree();
var sdtree = new Tree();
/* extra bits and base tables for length codes */
var length_bits = new Uint8Array(30);
var length_base = new Uint16Array(30);
/* extra bits and base tables for distance codes */
var dist_bits = new Uint8Array(30);
var dist_base = new Uint16Array(30);
/* special ordering of code length codes */
var clcidx = new Uint8Array([
16, 17, 18, 0, 8, 7, 9, 6,
10, 5, 11, 4, 12, 3, 13, 2,
14, 1, 15
]);
/* used by tinf_decode_trees, avoids allocations every call */
var code_tree = new Tree();
var lengths = new Uint8Array(288 + 32);
/* ----------------------- *
* -- utility functions -- *
* ----------------------- */
/* build extra bits and base tables */
function tinf_build_bits_base(bits, base, delta, first) {
var i, sum;
/* build bits table */
for (i = 0; i < delta; ++i) bits[i] = 0;
for (i = 0; i < 30 - delta; ++i) bits[i + delta] = i / delta | 0;
/* build base table */
for (sum = first, i = 0; i < 30; ++i) {
base[i] = sum;
sum += 1 << bits[i];
}
}
/* build the fixed huffman trees */
function tinf_build_fixed_trees(lt, dt) {
var i;
/* build fixed length tree */
for (i = 0; i < 7; ++i) lt.table[i] = 0;
lt.table[7] = 24;
lt.table[8] = 152;
lt.table[9] = 112;
for (i = 0; i < 24; ++i) lt.trans[i] = 256 + i;
for (i = 0; i < 144; ++i) lt.trans[24 + i] = i;
for (i = 0; i < 8; ++i) lt.trans[24 + 144 + i] = 280 + i;
for (i = 0; i < 112; ++i) lt.trans[24 + 144 + 8 + i] = 144 + i;
/* build fixed distance tree */
for (i = 0; i < 5; ++i) dt.table[i] = 0;
dt.table[5] = 32;
for (i = 0; i < 32; ++i) dt.trans[i] = i;
}
/* given an array of code lengths, build a tree */
var offs = new Uint16Array(16);
function tinf_build_tree(t, lengths, off, num) {
var i, sum;
/* clear code length count table */
for (i = 0; i < 16; ++i) t.table[i] = 0;
/* scan symbol lengths, and sum code length counts */
for (i = 0; i < num; ++i) t.table[lengths[off + i]]++;
t.table[0] = 0;
/* compute offset table for distribution sort */
for (sum = 0, i = 0; i < 16; ++i) {
offs[i] = sum;
sum += t.table[i];
}
/* create code->symbol translation table (symbols sorted by code) */
for (i = 0; i < num; ++i) {
if (lengths[off + i]) t.trans[offs[lengths[off + i]]++] = i;
}
}
/* ---------------------- *
* -- decode functions -- *
* ---------------------- */
/* get one bit from source stream */
function tinf_getbit(d) {
/* check if tag is empty */
if (!d.bitcount--) {
/* load next tag */
d.tag = d.source[d.sourceIndex++];
d.bitcount = 7;
}
/* shift bit out of tag */
var bit = d.tag & 1;
d.tag >>>= 1;
return bit;
}
/* read a num bit value from a stream and add base */
function tinf_read_bits(d, num, base) {
if (!num)
return base;
while (d.bitcount < 24) {
d.tag |= d.source[d.sourceIndex++] << d.bitcount;
d.bitcount += 8;
}
var val = d.tag & (0xffff >>> (16 - num));
d.tag >>>= num;
d.bitcount -= num;
return val + base;
}
/* given a data stream and a tree, decode a symbol */
function tinf_decode_symbol(d, t) {
while (d.bitcount < 24) {
d.tag |= d.source[d.sourceIndex++] << d.bitcount;
d.bitcount += 8;
}
var sum = 0, cur = 0, len = 0;
var tag = d.tag;
/* get more bits while code value is above sum */
do {
cur = 2 * cur + (tag & 1);
tag >>>= 1;
++len;
sum += t.table[len];
cur -= t.table[len];
} while (cur >= 0);
d.tag = tag;
d.bitcount -= len;
return t.trans[sum + cur];
}
/* given a data stream, decode dynamic trees from it */
function tinf_decode_trees(d, lt, dt) {
var hlit, hdist, hclen;
var i, num, length;
/* get 5 bits HLIT (257-286) */
hlit = tinf_read_bits(d, 5, 257);
/* get 5 bits HDIST (1-32) */
hdist = tinf_read_bits(d, 5, 1);
/* get 4 bits HCLEN (4-19) */
hclen = tinf_read_bits(d, 4, 4);
for (i = 0; i < 19; ++i) lengths[i] = 0;
/* read code lengths for code length alphabet */
for (i = 0; i < hclen; ++i) {
/* get 3 bits code length (0-7) */
var clen = tinf_read_bits(d, 3, 0);
lengths[clcidx[i]] = clen;
}
/* build code length tree */
tinf_build_tree(code_tree, lengths, 0, 19);
/* decode code lengths for the dynamic trees */
for (num = 0; num < hlit + hdist;) {
var sym = tinf_decode_symbol(d, code_tree);
switch (sym) {
case 16:
/* copy previous code length 3-6 times (read 2 bits) */
var prev = lengths[num - 1];
for (length = tinf_read_bits(d, 2, 3); length; --length) {
lengths[num++] = prev;
}
break;
case 17:
/* repeat code length 0 for 3-10 times (read 3 bits) */
for (length = tinf_read_bits(d, 3, 3); length; --length) {
lengths[num++] = 0;
}
break;
case 18:
/* repeat code length 0 for 11-138 times (read 7 bits) */
for (length = tinf_read_bits(d, 7, 11); length; --length) {
lengths[num++] = 0;
}
break;
default:
/* values 0-15 represent the actual code lengths */
lengths[num++] = sym;
break;
}
}
/* build dynamic trees */
tinf_build_tree(lt, lengths, 0, hlit);
tinf_build_tree(dt, lengths, hlit, hdist);
}
/* ----------------------------- *
* -- block inflate functions -- *
* ----------------------------- */
/* given a stream and two trees, inflate a block of data */
function tinf_inflate_block_data(d, lt, dt) {
while (1) {
var sym = tinf_decode_symbol(d, lt);
/* check for end of block */
if (sym === 256) {
return TINF_OK;
}
if (sym < 256) {
d.dest[d.destLen++] = sym;
} else {
var length, dist, offs;
var i;
sym -= 257;
/* possibly get more bits from length code */
length = tinf_read_bits(d, length_bits[sym], length_base[sym]);
dist = tinf_decode_symbol(d, dt);
/* possibly get more bits from distance code */
offs = d.destLen - tinf_read_bits(d, dist_bits[dist], dist_base[dist]);
/* copy match */
for (i = offs; i < offs + length; ++i) {
d.dest[d.destLen++] = d.dest[i];
}
}
}
}
/* inflate an uncompressed block of data */
function tinf_inflate_uncompressed_block(d) {
var length, invlength;
var i;
/* unread from bitbuffer */
while (d.bitcount > 8) {
d.sourceIndex--;
d.bitcount -= 8;
}
/* get length */
length = d.source[d.sourceIndex + 1];
length = 256 * length + d.source[d.sourceIndex];
/* get one's complement of length */
invlength = d.source[d.sourceIndex + 3];
invlength = 256 * invlength + d.source[d.sourceIndex + 2];
/* check length */
if (length !== (~invlength & 0x0000ffff))
return TINF_DATA_ERROR;
d.sourceIndex += 4;
/* copy block */
for (i = length; i; --i)
d.dest[d.destLen++] = d.source[d.sourceIndex++];
/* make sure we start next block on a byte boundary */
d.bitcount = 0;
return TINF_OK;
}
/* inflate stream from source to dest */
function tinf_uncompress(source, dest) {
var d = new Data(source, dest);
var bfinal, btype, res;
do {
/* read final block flag */
bfinal = tinf_getbit(d);
/* read block type (2 bits) */
btype = tinf_read_bits(d, 2, 0);
/* decompress block */
switch (btype) {
case 0:
/* decompress uncompressed block */
res = tinf_inflate_uncompressed_block(d);
break;
case 1:
/* decompress block with fixed huffman trees */
res = tinf_inflate_block_data(d, sltree, sdtree);
break;
case 2:
/* decompress block with dynamic huffman trees */
tinf_decode_trees(d, d.ltree, d.dtree);
res = tinf_inflate_block_data(d, d.ltree, d.dtree);
break;
default:
res = TINF_DATA_ERROR;
}
if (res !== TINF_OK)
throw new Error('Data error');
} while (!bfinal);
if (d.destLen < d.dest.length) {
if (typeof d.dest.slice === 'function')
return d.dest.slice(0, d.destLen);
else
return d.dest.subarray(0, d.destLen);
}
return d.dest;
}
/* -------------------- *
* -- initialization -- *
* -------------------- */
/* build fixed huffman trees */
tinf_build_fixed_trees(sltree, sdtree);
/* build extra bits and base tables */
tinf_build_bits_base(length_bits, length_base, 4, 3);
tinf_build_bits_base(dist_bits, dist_base, 2, 1);
/* fix a special case */
length_bits[28] = 0;
length_base[28] = 258;
module.exports = tinf_uncompress;
},{}],34:[function(require,module,exports){
(function (global){(function (){
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global global, define, Symbol, Reflect, Promise, SuppressedError, Iterator */
var __extends;
var __assign;
var __rest;
var __decorate;
var __param;
var __esDecorate;
var __runInitializers;
var __propKey;
var __setFunctionName;
var __metadata;
var __awaiter;
var __generator;
var __exportStar;
var __values;
var __read;
var __spread;
var __spreadArrays;
var __spreadArray;
var __await;
var __asyncGenerator;
var __asyncDelegator;
var __asyncValues;
var __makeTemplateObject;
var __importStar;
var __importDefault;
var __classPrivateFieldGet;
var __classPrivateFieldSet;
var __classPrivateFieldIn;
var __createBinding;
var __addDisposableResource;
var __disposeResources;
var __rewriteRelativeImportExtension;
(function (factory) {
var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
if (typeof define === "function" && define.amd) {
define("tslib", ["exports"], function (exports) { factory(createExporter(root, createExporter(exports))); });
}
else if (typeof module === "object" && typeof module.exports === "object") {
factory(createExporter(root, createExporter(module.exports)));
}
else {
factory(createExporter(root));
}
function createExporter(exports, previous) {
if (exports !== root) {
if (typeof Object.create === "function") {
Object.defineProperty(exports, "__esModule", { value: true });
}
else {
exports.__esModule = true;
}
}
return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };
}
})
(function (exporter) {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
__extends = function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
__assign = Object.assign || function (t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
__rest = function (s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
};
__decorate = function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
__param = function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
__esDecorate = function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
var _, done = false;
for (var i = decorators.length - 1; i >= 0; i--) {
var context = {};
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
if (kind === "accessor") {
if (result === void 0) continue;
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
if (_ = accept(result.get)) descriptor.get = _;
if (_ = accept(result.set)) descriptor.set = _;
if (_ = accept(result.init)) initializers.unshift(_);
}
else if (_ = accept(result)) {
if (kind === "field") initializers.unshift(_);
else descriptor[key] = _;
}
}
if (target) Object.defineProperty(target, contextIn.name, descriptor);
done = true;
};
__runInitializers = function (thisArg, initializers, value) {
var useValue = arguments.length > 2;
for (var i = 0; i < initializers.length; i++) {
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
}
return useValue ? value : void 0;
};
__propKey = function (x) {
return typeof x === "symbol" ? x : "".concat(x);
};
__setFunctionName = function (f, name, prefix) {
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
};
__metadata = function (metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
};
__awaiter = function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
__generator = function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
__exportStar = function(m, o) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
};
__createBinding = Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
__values = function (o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
__read = function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
/** @deprecated */
__spread = function () {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
};
/** @deprecated */
__spreadArrays = function () {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
__spreadArray = function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
__await = function (v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
};
__asyncGenerator = function (thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
};
__asyncDelegator = function (o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
};
__asyncValues = function (o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
};
__makeTemplateObject = function (cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
var __setModuleDefault = Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
};
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
__importStar = function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
__importDefault = function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
__classPrivateFieldGet = function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
__classPrivateFieldSet = function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
__classPrivateFieldIn = function (state, receiver) {
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
return typeof state === "function" ? receiver === state : state.has(receiver);
};
__addDisposableResource = function (env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async) inner = dispose;
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
env.stack.push({ value: value, dispose: dispose, async: async });
}
else if (async) {
env.stack.push({ async: true });
}
return value;
};
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
__disposeResources = function (env) {
function fail(e) {
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while (r = env.stack.pop()) {
try {
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
}
else s |= 1;
}
catch (e) {
fail(e);
}
}
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
};
__rewriteRelativeImportExtension = function (path, preserveJsx) {
if (typeof path === "string" && /^\.\.?\//.test(path)) {
return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
});
}
return path;
};
exporter("__extends", __extends);
exporter("__assign", __assign);
exporter("__rest", __rest);
exporter("__decorate", __decorate);
exporter("__param", __param);
exporter("__esDecorate", __esDecorate);
exporter("__runInitializers", __runInitializers);
exporter("__propKey", __propKey);
exporter("__setFunctionName", __setFunctionName);
exporter("__metadata", __metadata);
exporter("__awaiter", __awaiter);
exporter("__generator", __generator);
exporter("__exportStar", __exportStar);
exporter("__createBinding", __createBinding);
exporter("__values", __values);
exporter("__read", __read);
exporter("__spread", __spread);
exporter("__spreadArrays", __spreadArrays);
exporter("__spreadArray", __spreadArray);
exporter("__await", __await);
exporter("__asyncGenerator", __asyncGenerator);
exporter("__asyncDelegator", __asyncDelegator);
exporter("__asyncValues", __asyncValues);
exporter("__makeTemplateObject", __makeTemplateObject);
exporter("__importStar", __importStar);
exporter("__importDefault", __importDefault);
exporter("__classPrivateFieldGet", __classPrivateFieldGet);
exporter("__classPrivateFieldSet", __classPrivateFieldSet);
exporter("__classPrivateFieldIn", __classPrivateFieldIn);
exporter("__addDisposableResource", __addDisposableResource);
exporter("__disposeResources", __disposeResources);
exporter("__rewriteRelativeImportExtension", __rewriteRelativeImportExtension);
});
0 && (module.exports = {
__extends: __extends,
__assign: __assign,
__rest: __rest,
__decorate: __decorate,
__param: __param,
__esDecorate: __esDecorate,
__runInitializers: __runInitializers,
__propKey: __propKey,
__setFunctionName: __setFunctionName,
__metadata: __metadata,
__awaiter: __awaiter,
__generator: __generator,
__exportStar: __exportStar,
__createBinding: __createBinding,
__values: __values,
__read: __read,
__spread: __spread,
__spreadArrays: __spreadArrays,
__spreadArray: __spreadArray,
__await: __await,
__asyncGenerator: __asyncGenerator,
__asyncDelegator: __asyncDelegator,
__asyncValues: __asyncValues,
__makeTemplateObject: __makeTemplateObject,
__importStar: __importStar,
__importDefault: __importDefault,
__classPrivateFieldGet: __classPrivateFieldGet,
__classPrivateFieldSet: __classPrivateFieldSet,
__classPrivateFieldIn: __classPrivateFieldIn,
__addDisposableResource: __addDisposableResource,
__disposeResources: __disposeResources,
__rewriteRelativeImportExtension: __rewriteRelativeImportExtension,
});
}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],35:[function(require,module,exports){
var $c5L0i$base64js = require("base64-js");
var $c5L0i$unicodetrie = require("unicode-trie");
function $parcel$interopDefault(a) {
return a && a.__esModule ? a.default : a;
}
function $parcel$defineInteropFlag(a) {
Object.defineProperty(a, '__esModule', {value: true, configurable: true});
}
function $parcel$export(e, n, v, s) {
Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
}
$parcel$defineInteropFlag(module.exports);
$parcel$export(module.exports, "getCategory", () => $43d7963e56408b24$export$410364bbb673ddbc);
$parcel$export(module.exports, "getCombiningClass", () => $43d7963e56408b24$export$c03b919c6651ed55);
$parcel$export(module.exports, "getScript", () => $43d7963e56408b24$export$941569448d136665);
$parcel$export(module.exports, "getEastAsianWidth", () => $43d7963e56408b24$export$92f6187db8ca6d26);
$parcel$export(module.exports, "getNumericValue", () => $43d7963e56408b24$export$7d1258ebb7625a0d);
$parcel$export(module.exports, "isAlphabetic", () => $43d7963e56408b24$export$52c8ea63abd07594);
$parcel$export(module.exports, "isDigit", () => $43d7963e56408b24$export$727d9dbc4fbb948f);
$parcel$export(module.exports, "isPunctuation", () => $43d7963e56408b24$export$a5b49f4dc6a07d2c);
$parcel$export(module.exports, "isLowerCase", () => $43d7963e56408b24$export$7b6804e8df61fcf5);
$parcel$export(module.exports, "isUpperCase", () => $43d7963e56408b24$export$aebd617640818cda);
$parcel$export(module.exports, "isTitleCase", () => $43d7963e56408b24$export$de8b4ee23b2cf823);
$parcel$export(module.exports, "isWhiteSpace", () => $43d7963e56408b24$export$3c52dd84024ae72c);
$parcel$export(module.exports, "isBaseForm", () => $43d7963e56408b24$export$a11bdcffe109e74b);
$parcel$export(module.exports, "isMark", () => $43d7963e56408b24$export$e33ad6871e762338);
$parcel$export(module.exports, "default", () => $43d7963e56408b24$export$2e2bcd8739ae039);
var $29668e65f2091c2c$exports = {};
$29668e65f2091c2c$exports = JSON.parse('{"categories":["Cc","Zs","Po","Sc","Ps","Pe","Sm","Pd","Nd","Lu","Sk","Pc","Ll","So","Lo","Pi","Cf","No","Pf","Lt","Lm","Mn","Me","Mc","Nl","Zl","Zp","Cs","Co"],"combiningClasses":["Not_Reordered","Above","Above_Right","Below","Attached_Above_Right","Attached_Below","Overlay","Iota_Subscript","Double_Below","Double_Above","Below_Right","Above_Left","CCC10","CCC11","CCC12","CCC13","CCC14","CCC15","CCC16","CCC17","CCC18","CCC19","CCC20","CCC21","CCC22","CCC23","CCC24","CCC25","CCC30","CCC31","CCC32","CCC27","CCC28","CCC29","CCC33","CCC34","CCC35","CCC36","Nukta","Virama","CCC84","CCC91","CCC103","CCC107","CCC118","CCC122","CCC129","CCC130","CCC132","Attached_Above","Below_Left","Left","Kana_Voicing","CCC26","Right"],"scripts":["Common","Latin","Bopomofo","Inherited","Greek","Coptic","Cyrillic","Armenian","Hebrew","Arabic","Syriac","Thaana","Nko","Samaritan","Mandaic","Devanagari","Bengali","Gurmukhi","Gujarati","Oriya","Tamil","Telugu","Kannada","Malayalam","Sinhala","Thai","Lao","Tibetan","Myanmar","Georgian","Hangul","Ethiopic","Cherokee","Canadian_Aboriginal","Ogham","Runic","Tagalog","Hanunoo","Buhid","Tagbanwa","Khmer","Mongolian","Limbu","Tai_Le","New_Tai_Lue","Buginese","Tai_Tham","Balinese","Sundanese","Batak","Lepcha","Ol_Chiki","Braille","Glagolitic","Tifinagh","Han","Hiragana","Katakana","Yi","Lisu","Vai","Bamum","Syloti_Nagri","Phags_Pa","Saurashtra","Kayah_Li","Rejang","Javanese","Cham","Tai_Viet","Meetei_Mayek","null","Linear_B","Lycian","Carian","Old_Italic","Gothic","Old_Permic","Ugaritic","Old_Persian","Deseret","Shavian","Osmanya","Osage","Elbasan","Caucasian_Albanian","Linear_A","Cypriot","Imperial_Aramaic","Palmyrene","Nabataean","Hatran","Phoenician","Lydian","Meroitic_Hieroglyphs","Meroitic_Cursive","Kharoshthi","Old_South_Arabian","Old_North_Arabian","Manichaean","Avestan","Inscriptional_Parthian","Inscriptional_Pahlavi","Psalter_Pahlavi","Old_Turkic","Old_Hungarian","Hanifi_Rohingya","Old_Sogdian","Sogdian","Elymaic","Brahmi","Kaithi","Sora_Sompeng","Chakma","Mahajani","Sharada","Khojki","Multani","Khudawadi","Grantha","Newa","Tirhuta","Siddham","Modi","Takri","Ahom","Dogra","Warang_Citi","Nandinagari","Zanabazar_Square","Soyombo","Pau_Cin_Hau","Bhaiksuki","Marchen","Masaram_Gondi","Gunjala_Gondi","Makasar","Cuneiform","Egyptian_Hieroglyphs","Anatolian_Hieroglyphs","Mro","Bassa_Vah","Pahawh_Hmong","Medefaidrin","Miao","Tangut","Nushu","Duployan","SignWriting","Nyiakeng_Puachue_Hmong","Wancho","Mende_Kikakui","Adlam"],"eaw":["N","Na","A","W","H","F"]}');
const $43d7963e56408b24$var$trie = new (0, ($parcel$interopDefault($c5L0i$unicodetrie)))((0, ($parcel$interopDefault($c5L0i$base64js))).toByteArray("AAARAAAAAADwfAEAZXl5ONRt+/5bPVFZimRfKoTQJNm37CGE7Iw0j3UsTWKsoyI7kwyyTiEUzSD7NiEzhWYijH0wMVkHE4Mx49fzfo+3nuP4/fdZjvv+XNd5n/d9nef1WZvmKhTxiZndzDQBSEYQqxqKwnsKvGQucFh+6t6cJ792ePQBZv5S9yXSwkyjf/P4T7mTNnIAv1dOVhMlR9lflbUL9JeJguqsjvG9NTj/wLb566VAURnLo2vvRi89S3gW/33ihh2eXpDn40BIW7REl/7coRKIhAFlAiOtbLDTt6mMb4GzMF1gNnvX/sBxtbsAIjfztCNcQjcNDtLThRvuXu5M5g/CBjaLBE4lJm4qy/oZD97+IJryApcXfgWYlkvWbhfXgujOJKVu8B+ozqTLbxyJ5kNiR75CxDqfBM9eOlDMmGeoZ0iQbbS5VUplIwI+ZNXEKQVJxlwqjhOY7w3XwPesbLK5JZE+Tt4X8q8km0dzInsPPzbscrjBMVjF5mOHSeRdJVgKUjLTHiHqXSPkep8N/zFk8167KLp75f6RndkvzdfB6Uz3MmqvRArzdCbs1/iRZjYPLLF3U8Qs+H+Rb8iK51a6NIV2V9+07uJsTGFWpPz8J++7iRu2B6eAKlK/kujrLthwaD/7a6J5w90TusnH1JMAc+gNrql4aspOUG/RrsxUKmPzhHgP4Bleru+6Vfc/MBjgXVx7who94nPn7MPFrnwQP7g0k0Dq0h2GSKO6fTZ8nLodN1SiOUj/5EL/Xo1DBvRm0wmrh3x6phcJ20/9CuMr5h8WPqXMSasLoLHoufTmE7mzYrs6B0dY7KjuCogKqsvxnxAwXWvd9Puc9PnE8DOHT2INHxRlIyVHrqZahtfV2E/A2PDdtA3ewlRHMtFIBKO/T4IozWTQZ+mb+gdKuk/ZHrqloucKdsOSJmlWTSntWjcxVMjUmroXLM10I6TwDLnBq4LP69TxgVeyGsd8yHvhF8ydPlrNRSNs9EP7WmeuSE7Lu10JbOuQcJw/63sDp68wB9iwP5AO+mBpV0R5VDDeyQUFCel1G+4KHBgEVFS0YK+m2sXLWLuGTlkVAd97WwKKdacjWElRCuDRauf33l/yVcDF6sVPKeTes99FC1NpNWcpieGSV/IbO8PCTy5pbUR1U8lxzf4T+y6fZMxOz3LshkQLeeDSd0WmUrQgajmbktrxsb2AZ0ACw2Vgni+gV/m+KvCRWLg08Clx7uhql+v9XySGcjjOHlsp8vBw/e8HS7dtiqF6T/XcSXuaMW66GF1g4q9YyBadHqy3Y5jin1c7yZos6BBr6dsomSHxiUHanYtcYQwnMMZhRhOnaYJeyJzaRuukyCUh48+e/BUvk/aEfDp8ag+jD64BHxNnQ5v/E7WRk7eLjGV13I3oqy45YNONi/1op1oDr7rPjkhPsTXgUpQtGDPlIs55KhQaic9kSGs/UrZ2QKQOflB8MTEQxRF9pullToWO7Eplan6mcMRFnUu2441yxi23x+KqKlr7RWWsi9ZXMWlr8vfP3llk1m2PRj0yudccxBuoa7VfIgRmnFPGX6Pm1WIfMm/Rm4n/xTn8IGqA0GWuqgu48pEUO0U9nN+ZdIvFpPb7VDPphIfRZxznlHeVFebkd9l+raXy9BpTMcIUIvBfgHEb6ndGo8VUkxpief14KjzFOcaANfgvFpvyY8lE8lE4raHizLpluPzMks1hx/e1Hok5yV0p7qQH7GaYeMzzZTFvRpv6k6iaJ4yNqzBvN8J7B430h2wFm1IBPcqbou33G7/NWPgopl4Mllla6e24L3TOTVNkza2zv3QKuDWTeDpClCEYgTQ+5vEBSQZs/rMF50+sm4jofTgWLqgX1x3TkrDEVaRqfY/xZizFZ3Y8/DFEFD31VSfBQ5raEB6nHnZh6ddehtclQJ8fBrldyIh99LNnV32HzKEej04hk6SYjdauCa4aYW0ru/QxvQRGzLKOAQszf3ixJypTW3WWL6BLSF2EMCMIw7OUvWBC6A/gDc2D1jvBapMCc7ztx6jYczwTKsRLL6dMNXb83HS8kdD0pTMMj161zbVHkU0mhSHo9SlBDDXdN6hDvRGizmohtIyR3ot8tF5iUG4GLNcXeGvBudSFrHu+bVZb9jirNVG+rQPI51A7Hu8/b0UeaIaZ4UgDO68PkYx3PE2HWpKapJ764Kxt5TFYpywMy4DLQqVRy11I7SOLhxUFmqiEK52NaijWArIfCg6qG8q5eSiwRCJb1R7GDJG74TrYgx/lVq7w9++Kh929xSJEaoSse5fUOQg9nMAnIZv+7fwVRcNv3gOHI46Vb5jYUC66PYHO6lS+TOmvEQjuYmx4RkffYGxqZIp/DPWNHAixbRBc+XKE3JEOgs4jIwu/dSAwhydruOGF39co91aTs85JJ3Z/LpXoF43hUwJsb/M1Chzdn8HX8vLXnqWUKvRhNLpfAF4PTFqva1sBQG0J+59HyYfmQ3oa4/sxZdapVLlo/fooxSXi/dOEQWIWq8E0FkttEyTFXR2aNMPINMIzZwCNEheYTVltsdaLkMyKoEUluPNAYCM2IG3br0DLy0fVNWKHtbSKbBjfiw7Lu06gQFalC7RC9BwRMSpLYDUo9pDtDfzwUiPJKLJ2LGcSphWBadOI/iJjNqUHV7ucG8yC6+iNM9QYElqBR7ECFXrcTgWQ3eG/tCWacT9bxIkfmxPmi3vOd36KxihAJA73vWNJ+Y9oapXNscVSVqS5g15xOWND/WuUCcA9YAAg6WFbjHamrblZ5c0L6Zx1X58ZittGcfDKU697QRSqW/g+RofNRyvrWMrBn44cPvkRe2HdTu/Cq01C5/riWPHZyXPKHuSDDdW8c1XPgd6ogvLh20qEIu8c19sqr4ufyHrwh37ZN5MkvY1dsGmEz9pUBTxWrvvhNyODyX2Q1k/fbX/T/vbHNcBrmjgDtvBdtZrVtiIg5iXQuzO/DEMvRX8Mi1zymSlt92BGILeKItjoShJXE/H7xwnf0Iewb8BFieJ9MflEBCQYEDm8eZniiEPfGoaYiiEdhQxHQNr2AuRdmbL9mcl18Kumh+HEZLp6z+j35ML9zTbUwahUZCyQQOgQrGfdfQtaR/OYJ/9dYXb2TWZFMijfCA8Nov4sa5FFDUe1T68h4q08WDE7JbbDiej4utRMR9ontevxlXv6LuJTXt1YEv8bDzEt683PuSsIN0afvu0rcBu9AbXZbkOG3K3AhtqQ28N23lXm7S3Yn6KXmAhBhz+GeorJJ4XxO/b3vZk2LXp42+QvsVxGSNVpfSctIFMTR1bD9t70i6sfNF3WKz/uKDEDCpzzztwhL45lsw89H2IpWN10sXHRlhDse9KCdpP5qNNpU84cTY+aiqswqR8XZ9ea0KbVRwRuOGQU3csAtV2fSbnq47U6es6rKlWLWhg3s/B9C9g+oTyp6RtIldR51OOkP5/6nSy6itUVPcMNOp4M/hDdKOz3uK6srbdxOrc2cJgr1Sg02oBxxSky6V7JaG+ziNwlfqnjnvh2/uq1lKfbp+qpwq/D/5OI5gkFl5CejKGxfc2YVJfGqc4E0x5e9PHK2ukbHNI7/RZV6LNe65apbTGjoCaQls0txPPbmQbCQn+/upCoXRZy9yzorWJvZ0KWcbXlBxU/d5I4ERUTxMuVWhSMmF677LNN7NnLwsmKawXkCgbrpcluOl0WChR1qhtSrxGXHu251dEItYhYX3snvn1gS2uXuzdTxCJjZtjsip0iT2sDC0qMS7Bk9su2NyXjFK5/f5ZoWwofg3DtTyjaFqspnOOTSh8xK/CKUFS57guVEkw9xoQuRCwwEO9Lu9z2vYxSa9NFV8DvSxv2C4WYLYF8Nrc4DzWkzNsk81JJOlZ/LYJrGCoj4MmZpnf3AXmzxT4rtl9jsqljEyedz468SGKdBiQzyz/qWKEhFg45ZczlZZ3KGL3l6sn+3TTa3zMVMhPa1obGp/z+fvY0QXTrJTf1XAT3EtQdUfYYlmWZyvPZ/6rWwU7UOQei7pVE0osgN94Iy+T1+omE6z4Rh2O20FjgBeK2y1mcoFiMDOJvuZPn5Moy9fmFH3wyfKvn4+TwfLvt/lHTTVnvrtoUWRBiQXhiNM8nE6ZoWeux/Z0b2unRcdUzdDpmL7CAgd1ToRXwgmHTZOgiGtVT+xr1QH9ObebRTT4NzL+XSpLuuWp62GqQvJVTPoZOeJCb6gIwd9XHMftQ+Kc08IKKdKQANSJ1a2gve3JdRhO0+tNiYzWAZfd7isoeBu67W7xuK8WX7nhJURld98Inb0t/dWOSau/kDvV4DJo/cImw9AO2Gvq0F2n0M7yIZKL8amMbjYld+qFls7hq8Acvq97K2PrCaomuUiesu7qNanGupEl6J/iem8lyr/NMnsTr6o41PO0yhQh3hPFN0wJP7S830je9iTBLzUNgYH+gUZpROo3rN2qgCI+6GewpX8w8CH+ro6QrWiStqmcMzVa3vEel+3/dDxMp0rDv1Q6wTMS3K64zTT6RWzK1y643im25Ja7X2ePCV2mTswd/4jshZPo4bLnerqIosq/hy2bKUAmVn9n4oun1+a0DIZ56UhVwmZHdUNpLa8gmPvxS1eNvCF1T0wo1wKPdCJi0qOrWz7oYRTzgTtkzEzZn308XSLwUog4OWGKJzCn/3FfF9iA32dZHSv30pRCM3KBY9WZoRhtdK/ChHk6DEQBsfV6tN2o1Cn0mLtPBfnkS+qy1L2xfFe9TQPtDE1Be44RTl82E9hPT2rS2+93LFbzhQQO3C/hD2jRFH3BWWbasAfuMhRJFcTri73eE835y016s22DjoFJ862WvLj69fu2TgSF3RHia9D5DSitlQAXYCnbdqjPkR287Lh6dCHDapos+eFDvcZPP2edPmTFxznJE/EBLoQQ0Qmn9EkZOyJmHxMbvKYb8o21ZHmv5YLqgsEPk9gWZwYQY9wLqGXuax/8QlV5qDaPbq9pLPT1yp+zOWKmraEy1OUJI7zdEcEmvBpbdwLrDCgEb2xX8S/nxZgjK4bRi+pbOmbh8bEeoPvU/L9ndx9kntlDALbdAvp0O8ZC3zSUnFg4cePsw7jxewWvL7HRSBLUn6J7vTH9uld5N76JFPgBCdXGF221oEJk++XfRwXplLSyrVO7HFWBEs99nTazKveW3HpbD4dH/YmdAl+lwbSt8BQWyTG7jAsACI7bPPUU9hI9XUHWqQOuezHzUjnx5Qqs6T1qNHfTTHleDtmqK7flA9a0gz2nycIpz1FHBuWxKNtUeTdqP29Fb3tv+tl5JyBqXoR+vCsdzZwZUhf6Lu8bvkB9yQP4x7GGegB0ym0Lpl03Q7e+C0cDsm9GSDepCDji7nUslLyYyluPfvLyKaDSX4xpR+nVYQjQQn5F8KbY1gbIVLiK1J3mW90zTyR1bqApX2BlWh7KG8LAY9/S9nWC0XXh9pZZo6xuir12T43rkaGfQssbQyIslA7uJnSHOV22NhlNtUo0czxPAsXhh8tIQYaTM4l/yAlZlydTcXhlG22Gs/n3BxKBd/3ZjYwg3NaUurVXhNB+afVnFfNr9TbC9ksNdvwpNfeHanyJ8M6GrIVfLlYAPv0ILe4dn0Z+BJSbJkN7eZY/c6+6ttDYcIDeUKIDXqUSE42Xdh5nRbuaObozjht0HJ5H1e+em+NJi/+8kQlyjCbJpPckwThZeIF9/u7lrVIKNeJLCN/TpPAeXxvd31/CUDWHK9MuP1V1TJgngzi4V0qzS3SW3Qy5UiGHqg02wQa5tsEl9s/X9nNMosgLlUgZSfCBj1DiypLfhr9/r0nR0XY2tmhDOcUS4E7cqa4EJBhzqvpbZa35Q5Iz5EqmhYiOGDAYk606Tv74+KGfPjKVuP15rIzgW0I7/niOu9el/sn2bRye0gV+GrePDRDMHjwO1lEdeXH8N+UTO3IoN18kpI3tPxz+fY+n2MGMSGFHAx/83tKeJOl+2i+f1O9v6FfEDBbqrw+lpM8Anav7zHNr7hE78nXUtPNodMbCnITWA7Ma/IHlZ50F9hWge/wzOvSbtqFVFtkS8Of2nssjZwbSFdU+VO8z6tCEc9UA9ACxT5zIUeSrkBB/v1krOpm7bVMrGxEKfI6LcnpB4D8bvn2hDKGqKrJaVAJuDaBEY3F7eXyqnFWlOoFV/8ZLspZiZd7orXLhd4mhHQgbuKbHjJWUzrnm0Dxw/LJLzXCkh7slMxKo8uxZIWZfdKHlfI7uj3LP6ARAuWdF7ZmZ7daOKqKGbz5LxOggTgS39oEioYmrqkCeUDvbxkBYKeHhcLmMN8dMF01ZMb32IpL/cH8R7VHQSI5I0YfL14g9d7P/6cjB1JXXxbozEDbsrPdmL8ph7QW10jio+v7YsqHKQ6xrBbOVtxU0/nFfzUGZwIBLwyUvg49ii+54nv9FyECBpURnQK4Ox6N7lw5fsjdd5l/2SwBcAHMJoyjO1Pifye2dagaOwCVMqdJWAo77pvBe0zdJcTWu5fdzPNfV2p1pc7/JKQ8zhKkwsOELUDhXygPJ5oR8Vpk2lsCen3D3QOQp2zdrSZHjVBstDF/wWO98rrkQ6/7zt/Drip7OHIug1lomNdmRaHRrjmqeodn22sesQQPgzimPOMqC60a5+i/UYh51uZm+ijWkkaI2xjrBO2558DZNZMiuDQlaVAvBy2wLn/bR3FrNzfnO/9oDztYqxZrr7JMIhqmrochbqmQnKowxW29bpqTaJu7kW1VotC72QkYX8OoDDdMDwV1kJRk3mufgJBzf+iwFRJ7XWQwO5ujVglgFgHtycWiMLx5N+6XU+TulLabWjOzoao03fniUW0xvIJNPbk7CQlFZd/RCOPvgQbLjh5ITE8NVJeKt3HGr6JTnFdIzcVOlEtwqbIIX0IM7saC+4N5047MTJ9+Wn11EhyEPIlwsHE5utCeXRjQzlrR+R1Cf/qDzcNbqLXdk3J7gQ39VUrrEkS/VMWjjg+t2oYrqB0tUZClcUF6+LBC3EQ7KnGIwm/qjZX4GKPtjTX1zQKV6nPAb2t/Rza5IqKRf8i2DFEhV/YSifX0YwsiF6TQnp48Gr65TFq0zUe6LGjiY7fq0LSGKL1VnC6ESI2yxvt3XqBx53B3gSlGFeJcPbUbonW1E9E9m4NfuwPh+t5QjRxX34lvBPVxwQd7aeTd+r9dw5CiP1pt8wMZoMdni7GapYdo6KPgeQKcmlFfq4UYhvV0IBgeiR3RnTMBaqDqpZrTRyLdsp4l0IXZTdErfH0sN3dqBG5vRIx3VgCYcHmmkqJ8Hyu3s9K9uBD1d8cZUEx3qYcF5vsqeRpF1GOg8emeWM2OmBlWPdZ6qAXwm3nENFyh+kvXk132PfWAlN0kb7yh4fz2T7VWUY/hEXX5DvxGABC03XRpyOG8t/u3Gh5tZdpsSV9AWaxJN7zwhVglgII1gV28tUViyqn4UMdIh5t+Ea2zo7PO48oba0TwQbiSZOH4YhD578kPF3reuaP7LujPMsjHmaDuId9XEaZBCJhbXJbRg5VCk3KJpryH/+8S3wdhR47pdFcmpZG2p0Bpjp/VbvalgIZMllYX5L31aMPdt1J7r/7wbixt0Mnz2ZvNGTARHPVD+2O1D8SGpWXlVnP2ekgon55YiinADDynyaXtZDXueVqbuTi8z8cHHK325pgqM+mWZwzHeEreMvhZopAScXM14SJHpGwZyRljMlDvcMm9FZ/1e9+r/puOnpXOtc9Iu2fmgBfEP9cGW1Fzb1rGlfJ08pACtq1ZW18bf2cevebzVeHbaA50G9qoUp39JWdPHbYkPCRXjt4gzlq3Cxge28Mky8MoS/+On72kc+ZI2xBtgJytpAQHQ1zrEddMIVyR5urX6yBNu8v5lKC8eLdGKTJtbgIZ3ZyTzSfWmx9f+cvcJe8yM39K/djkp2aUTE/9m2Lj5jg7b8vdRAer7DO3SyLNHs1CAm5x5iAdh2yGJYivArZbCBNY88Tw+w+C1Tbt7wK3zl2rzTHo/D8/gb3c3mYrnEIEipYqPUcdWjnTsSw471O3EUN7Gtg4NOAs9PJrxm03VuZKa5xwXAYCjt7Gs01Km6T2DhOYUMoFcCSu7Hk1p3yP1eG+M3v3Q5luAze6WwBnZIYO0TCucPWK+UJ36KoJ8Y+vpavhLO8g5ed704IjlQdfemrMu//EvPYXTQSGIPPfiagJS9nMqP5IvkxN9pvuJz7h8carPXTKMq8jnTeL0STan6dnLTAqwIswcIwWDR2KwbGddAVN8SYWRB7kfBfBRkSXzvHlIF8D6jo64kUzYk5o/n8oLjKqat0rdXvQ86MkwQGMnnlcasqPPT2+mVtUGb32KuH6cyZQenrRG11TArcAl27+nvOMBDe++EKHf4YdyGf7mznzOz33cFFGEcv329p4qG2hoaQ8ULiMyVz6ENcxhoqGnFIdupcn7GICQWuw3yO3W8S33mzCcMYJ8ywc7U7rmaQf/W5K63Gr4bVTpXOyOp4tbaPyIaatBNpXqlmQUTSZXjxPr19+73PSaT+QnI35YsWn6WpfJjRtK8vlJZoTSgjaRU39AGCkWOZtifJrnefCrqwTKDFmuWUCukEsYcRrMzCoit28wYpP7kSVjMD8WJYQiNc2blMjuqYegmf6SsfC1jqz8XzghMlOX+gn/MKZmgljszrmehEa4V98VreJDxYvHr3j7IeJB9/sBZV41BWT/AZAjuC5XorlIPnZgBAniBEhanp0/0+qZmEWDpu8ige1hUPIyTo6T6gDEcFhWSoduNh8YSu65KgMOGBw7VlNYzNIgwHtq9KP2yyTVysqX5v12sf7D+vQUdR2dRDvCV40rIInXSLWT/yrC6ExOQxBJwIDbeZcl3z1yR5Rj3l8IGpxspapnvBL+fwupA3b6fkFceID9wgiM1ILB0cHVdvo/R4xg8yqKXT8efl0GnGX1/27FUYeUW2L/GNRGGWVGp3i91oaJkb4rybENHre9a2P5viz/yqk8ngWUUS+Kv+fu+9BLFnfLiLXOFcIeBJLhnayCiuDRSqcx0Qu68gVsGYc6EHD500Fkt+gpDj6gvr884n8wZ5o6q7xtL5wA0beXQnffWYkZrs2NGIRgQbsc5NB302SVx+R4ROvmgZaR8wBcji128BMfJ9kcvJ4DC+bQ57kRmv5yxgU4ngZfn0/JNZ8JBwxjTqS+s9kjJFG1unGUGLwMiIuXUD9EFhNIJuyCEAmVZSIGKH4G6v1gRR1LyzQKH2ZqiI1DnHMoDEZspbDjTeaFIAbSvjSq3A+n46y9hhVM8wIpnARSXyzmOD96d9UXvFroSPgGw1dq2vdEqDq9fJN1EbL2WulNmHkFDvxSO9ZT/RX/Bw2gA/BrF90XrJACereVfbV/YXaKfp77Nmx5NjEIUlxojsy7iN7nBHSZigfsbFyVOX1ZTeCCxvqnRSExP4lk5ZeYlRu9caaa743TWNdchRIhEWwadsBIe245C8clpaZ4zrPsk+OwXzxWCvRRumyNSLW5KWaSJyJU95cwheK76gr7228spZ3hmTtLyrfM2QRFqZFMR8/Q6yWfVgwTdfX2Ry4w3+eAO/5VT5nFb5NlzXPvBEAWrNZ6Q3jbH0RF4vcbp+fDngf/ywpoyNQtjrfvcq93AVb1RDWRghvyqgI2BkMr1rwYi8gizZ0G9GmPpMeqPerAQ0dJbzx+KAFM4IBq6iSLpZHUroeyfd9o5o+4fR2EtsZBoJORQEA4SW0CmeXSnblx2e9QkCHIodyqV6+g5ETEpZsLqnd/Na60EKPX/tQpPEcO+COIBPcQdszDzSiHGyQFPly/7KciUh1u+mFfxTCHGv9nn2WqndGgeGjQ/kr02qmTBX7Hc1qiEvgiSz1Tz/sy7Es29wvn6FrDGPP7asXlhOaiHxOctPvTptFA1kHFUk8bME7SsTSnGbFbUrssxrq70LhoSh5OwvQna+w84XdXhZb2sloJ4ZsCg3j+PrjJL08/JBi5zGd6ud/ZxhmcGKLOXPcNunQq5ESW92iJvfsuRrNYtawWwSmNhPYoFj2QqWNF0ffLpGt/ad24RJ8vkb5sXkpyKXmvFG5Vcdzf/44k3PBL/ojJ52+kWGzOArnyp5f969oV3J2c4Li27Nkova9VwRNVKqN0V+gV+mTHitgkXV30aWd3A1RSildEleiNPA+5cp+3+T7X+xfHiRZXQ1s4FA9TxIcnveQs9JSZ5r5qNmgqlW4zMtZ6rYNvgmyVcywKtu8ZxnSbS5vXlBV+NXdIfi3+xzrnJ0TkFL+Un8v1PWOC2PPFCjVPq7qTH7mOpzOYj/b4h0ceT+eHgr97Jqhb1ziVfeANzfN8bFUhPKBi7hJBCukQnB0aGjFTYLJPXL26lQ2b80xrOD5cFWgA8hz3St0e69kwNnD3+nX3gy12FjrjO+ddRvvvfyV3SWbXcxqNHfmsb9u1TV+wHTb9B07/L2sB8WUHJ9eeNomDyysEWZ0deqEhH/oWI2oiEh526gvAK1Nx2kIhNvkYR+tPYHEa9j+nd1VBpQP1uzSjIDO+fDDB7uy029rRjDC5Sk6aKczyz1D5uA9Lu+Rrrapl8JXNL3VRllNQH2K1ZFxOpX8LprttfqQ56MbPM0IttUheXWD/mROOeFqGUbL+kUOVlXLTFX/525g4faLEFO4qWWdmOXMNvVjpIVTWt650HfQjX9oT3Dg5Au6+v1/Ci78La6ZOngYCFPT1AUwxQuZ0yt5xKdNXLaDTISMTeCj16XTryhM36K2mfGRIgot71voWs8tTpL/f1rvcwv3LSDf+/G8THCT7NpfHWcW+lsF/ol8q9Bi6MezNTqp0rpp/kJRiVfNrX/w27cRRTu8RIIqtUblBMkxy4jwAVqCjUJkiPBj2cAoVloG8B2/N5deLdMhDb7xs5nhd3dubJhuj8WbaFRyu1L678DHhhA+rMimNo4C1kGpp0tD/qnCfCFHejpf0LJX43OTr578PY0tnIIrlWyNYyuR/ie6j2xNb1OV6u0dOX/1Dtcd7+ya9W+rY2LmnyQMtk8SMLTon8RAdwOaN2tNg5zVnDKlmVeOxPV2vhHIo9QEPV7jc3f+zVDquiNg1OaHX3cZXJDRY5MJpo+VanAcmqp4oasYLG+wrXUL5vJU0kqk2hGEskhP+Jjigrz1l6QnEwp6n8PMVeJp70Ii6ppeaK9GhF6fJE00ceLyxv08tKiPat4QdxZFgSbQknnEiCLD8Qc1rjazVKM3r3gXnnMeONgdz/yFV1q+haaN+wnF3Fn4uYCI9XsKOuVwDD0LsCO/f0gj5cmxCFcr7sclIcefWjvore+3aSU474cyqDVxH7w1RX3CHsaqsMRX17ZLgjsDXws3kLm2XJdM3Ku383UXqaHqsywzPhx7NFir0Fqjym/w6cxD2U9ypa3dx7Z12w/fi3Jps8sqJ8f8Ah8aZAvkHXvIRyrsxK7rrFaNNdNvjI8+3Emri195DCNa858anj2Qdny6Czshkn4N2+1m+k5S8sunX3Ja7I+JutRzg1mc2e9Yc0Zv9PZn1SwhxIdU9sXwZRTd/J5FoUm0e+PYREeHg3oc2YYzGf2xfJxXExt4pT3RfDRHvMXLUmoXOy63xv5pLuhOEax0dRgSywZ/GH+YBXFgCeTU0hZ8SPEFsn8punp1Kurd1KgXxUZ+la3R5+4ePGR4ZF5UQtOa83+Vj8zh80dfzbhxWCeoJnQ4dkZJM4drzknZOOKx2n3WrvJnzFIS8p0xeic+M3ZRVXIp10tV2DyYKwRxLzulPwzHcLlYTxl4PF7v8l106Azr+6wBFejbq/3P72C/0j78cepY9990/d4eAurn2lqdGKLU8FffnMw7cY7pVeXJRMU73Oxwi2g2vh/+4gX8dvbjfojn/eLVhhYl8GthwCQ50KcZq4z2JeW5eeOnJWFQEnVxDoG459TaC4zXybECEoJ0V5q1tXrQbDMtUxeTV6Pdt1/zJuc7TJoV/9YZFWxUtCf6Ou3Vd/vR/vG0138hJQrHkNeoep5dLe+6umcSquKvMaFpm3EZHDBOvCi0XYyIFHMgX7Cqp3JVXlxJFwQfHSaIUEbI2u1lBVUdlNw4Qa9UsLPEK94Qiln3pyKxQVCeNlx8yd7EegVNQBkFLabKvnietYVB4IPZ1fSor82arbgYec8aSdFMaIluYTYuNx32SxfrjKUdPGq+UNp5YpydoEG3xVLixtmHO9zXxKAnHnPuH2fPGrjx0GcuCDEU+yXUtXh6nfUL+cykws1gJ5vkfYFaFBr9PdCXvVf35OJQxzUMmWjv0W6uGJK11uAGDqSpOwCf6rouSIjPVgw57cJCOQ4b9tkI/Y5WNon9Swe72aZryKo8d+HyHBEdWJKrkary0LIGczA4Irq353Wc0Zga3om7UQiAGCvIl8GGyaqz5zH+1gMP5phWUCpKtttWIyicz09vXg76GxkmiGSMQ06Z9X8BUwqOtauDbPIf4rpK/yYoeAHxJ9soXS9VDe1Aw+awOOxaN8foLrif0TXBvQ55dtRtulRq9emFDBxlQcqKCaD8NeTSE7FOHvcjf/+oKbbtRqz9gbofoc2EzQ3pL6W5JdfJzAWmOk8oeoECe90lVMruwl/ltM015P/zIPazqvdvFmLNVHMIZrwiQ2tIKtGh6PDVH+85ew3caqVt2BsDv5rOcu3G9srQWd7NmgtzCRUXLYknYRSwtH9oUtkqyN3CfP20xQ1faXQl4MEmjQehWR6GmGnkdpYNQYeIG408yAX7uCZmYUic9juOfb+Re28+OVOB+scYK4DaPcBe+5wmji9gymtkMpKo4UKqCz7yxzuN8VIlx9yNozpRJpNaWHtaZVEqP45n2JemTlYBSmNIK1FuSYAUQ1yBLnKxevrjayd+h2i8PjdB3YY6b0nr3JuOXGpPMyh4V2dslpR3DFEvgpsBLqhqLDOWP4yEvIL6f21PpA7/8B"));
const $43d7963e56408b24$var$log2 = Math.log2 || ((n)=>Math.log(n) / Math.LN2);
const $43d7963e56408b24$var$bits = (n)=>$43d7963e56408b24$var$log2(n) + 1 | 0;
// compute the number of bits stored for each field
const $43d7963e56408b24$var$CATEGORY_BITS = $43d7963e56408b24$var$bits((0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).categories.length - 1);
const $43d7963e56408b24$var$COMBINING_BITS = $43d7963e56408b24$var$bits((0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).combiningClasses.length - 1);
const $43d7963e56408b24$var$SCRIPT_BITS = $43d7963e56408b24$var$bits((0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).scripts.length - 1);
const $43d7963e56408b24$var$EAW_BITS = $43d7963e56408b24$var$bits((0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).eaw.length - 1);
const $43d7963e56408b24$var$NUMBER_BITS = 10;
// compute shift and mask values for each field
const $43d7963e56408b24$var$CATEGORY_SHIFT = $43d7963e56408b24$var$COMBINING_BITS + $43d7963e56408b24$var$SCRIPT_BITS + $43d7963e56408b24$var$EAW_BITS + $43d7963e56408b24$var$NUMBER_BITS;
const $43d7963e56408b24$var$COMBINING_SHIFT = $43d7963e56408b24$var$SCRIPT_BITS + $43d7963e56408b24$var$EAW_BITS + $43d7963e56408b24$var$NUMBER_BITS;
const $43d7963e56408b24$var$SCRIPT_SHIFT = $43d7963e56408b24$var$EAW_BITS + $43d7963e56408b24$var$NUMBER_BITS;
const $43d7963e56408b24$var$EAW_SHIFT = $43d7963e56408b24$var$NUMBER_BITS;
const $43d7963e56408b24$var$CATEGORY_MASK = (1 << $43d7963e56408b24$var$CATEGORY_BITS) - 1;
const $43d7963e56408b24$var$COMBINING_MASK = (1 << $43d7963e56408b24$var$COMBINING_BITS) - 1;
const $43d7963e56408b24$var$SCRIPT_MASK = (1 << $43d7963e56408b24$var$SCRIPT_BITS) - 1;
const $43d7963e56408b24$var$EAW_MASK = (1 << $43d7963e56408b24$var$EAW_BITS) - 1;
const $43d7963e56408b24$var$NUMBER_MASK = (1 << $43d7963e56408b24$var$NUMBER_BITS) - 1;
function $43d7963e56408b24$export$410364bbb673ddbc(codePoint) {
const val = $43d7963e56408b24$var$trie.get(codePoint);
return (0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).categories[val >> $43d7963e56408b24$var$CATEGORY_SHIFT & $43d7963e56408b24$var$CATEGORY_MASK];
}
function $43d7963e56408b24$export$c03b919c6651ed55(codePoint) {
const val = $43d7963e56408b24$var$trie.get(codePoint);
return (0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).combiningClasses[val >> $43d7963e56408b24$var$COMBINING_SHIFT & $43d7963e56408b24$var$COMBINING_MASK];
}
function $43d7963e56408b24$export$941569448d136665(codePoint) {
const val = $43d7963e56408b24$var$trie.get(codePoint);
return (0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).scripts[val >> $43d7963e56408b24$var$SCRIPT_SHIFT & $43d7963e56408b24$var$SCRIPT_MASK];
}
function $43d7963e56408b24$export$92f6187db8ca6d26(codePoint) {
const val = $43d7963e56408b24$var$trie.get(codePoint);
return (0, (/*@__PURE__*/$parcel$interopDefault($29668e65f2091c2c$exports))).eaw[val >> $43d7963e56408b24$var$EAW_SHIFT & $43d7963e56408b24$var$EAW_MASK];
}
function $43d7963e56408b24$export$7d1258ebb7625a0d(codePoint) {
let val = $43d7963e56408b24$var$trie.get(codePoint);
let num = val & $43d7963e56408b24$var$NUMBER_MASK;
if (num === 0) return null;
else if (num <= 50) return num - 1;
else if (num < 0x1e0) {
const numerator = (num >> 4) - 12;
const denominator = (num & 0xf) + 1;
return numerator / denominator;
} else if (num < 0x300) {
val = (num >> 5) - 14;
let exp = (num & 0x1f) + 2;
while(exp > 0){
val *= 10;
exp--;
}
return val;
} else {
val = (num >> 2) - 0xbf;
let exp = (num & 3) + 1;
while(exp > 0){
val *= 60;
exp--;
}
return val;
}
}
function $43d7963e56408b24$export$52c8ea63abd07594(codePoint) {
const category = $43d7963e56408b24$export$410364bbb673ddbc(codePoint);
return category === "Lu" || category === "Ll" || category === "Lt" || category === "Lm" || category === "Lo" || category === "Nl";
}
function $43d7963e56408b24$export$727d9dbc4fbb948f(codePoint) {
return $43d7963e56408b24$export$410364bbb673ddbc(codePoint) === "Nd";
}
function $43d7963e56408b24$export$a5b49f4dc6a07d2c(codePoint) {
const category = $43d7963e56408b24$export$410364bbb673ddbc(codePoint);
return category === "Pc" || category === "Pd" || category === "Pe" || category === "Pf" || category === "Pi" || category === "Po" || category === "Ps";
}
function $43d7963e56408b24$export$7b6804e8df61fcf5(codePoint) {
return $43d7963e56408b24$export$410364bbb673ddbc(codePoint) === "Ll";
}
function $43d7963e56408b24$export$aebd617640818cda(codePoint) {
return $43d7963e56408b24$export$410364bbb673ddbc(codePoint) === "Lu";
}
function $43d7963e56408b24$export$de8b4ee23b2cf823(codePoint) {
return $43d7963e56408b24$export$410364bbb673ddbc(codePoint) === "Lt";
}
function $43d7963e56408b24$export$3c52dd84024ae72c(codePoint) {
const category = $43d7963e56408b24$export$410364bbb673ddbc(codePoint);
return category === "Zs" || category === "Zl" || category === "Zp";
}
function $43d7963e56408b24$export$a11bdcffe109e74b(codePoint) {
const category = $43d7963e56408b24$export$410364bbb673ddbc(codePoint);
return category === "Nd" || category === "No" || category === "Nl" || category === "Lu" || category === "Ll" || category === "Lt" || category === "Lm" || category === "Lo" || category === "Me" || category === "Mc";
}
function $43d7963e56408b24$export$e33ad6871e762338(codePoint) {
const category = $43d7963e56408b24$export$410364bbb673ddbc(codePoint);
return category === "Mn" || category === "Me" || category === "Mc";
}
var // Backwards compatibility.
$43d7963e56408b24$export$2e2bcd8739ae039 = {
getCategory: $43d7963e56408b24$export$410364bbb673ddbc,
getCombiningClass: $43d7963e56408b24$export$c03b919c6651ed55,
getScript: $43d7963e56408b24$export$941569448d136665,
getEastAsianWidth: $43d7963e56408b24$export$92f6187db8ca6d26,
getNumericValue: $43d7963e56408b24$export$7d1258ebb7625a0d,
isAlphabetic: $43d7963e56408b24$export$52c8ea63abd07594,
isDigit: $43d7963e56408b24$export$727d9dbc4fbb948f,
isPunctuation: $43d7963e56408b24$export$a5b49f4dc6a07d2c,
isLowerCase: $43d7963e56408b24$export$7b6804e8df61fcf5,
isUpperCase: $43d7963e56408b24$export$aebd617640818cda,
isTitleCase: $43d7963e56408b24$export$de8b4ee23b2cf823,
isWhiteSpace: $43d7963e56408b24$export$3c52dd84024ae72c,
isBaseForm: $43d7963e56408b24$export$a11bdcffe109e74b,
isMark: $43d7963e56408b24$export$e33ad6871e762338
};
},{"base64-js":9,"unicode-trie":36}],36:[function(require,module,exports){
const inflate = require('tiny-inflate');
const { swap32LE } = require('./swap');
// Shift size for getting the index-1 table offset.
const SHIFT_1 = 6 + 5;
// Shift size for getting the index-2 table offset.
const SHIFT_2 = 5;
// Difference between the two shift sizes,
// for getting an index-1 offset from an index-2 offset. 6=11-5
const SHIFT_1_2 = SHIFT_1 - SHIFT_2;
// Number of index-1 entries for the BMP. 32=0x20
// This part of the index-1 table is omitted from the serialized form.
const OMITTED_BMP_INDEX_1_LENGTH = 0x10000 >> SHIFT_1;
// Number of entries in an index-2 block. 64=0x40
const INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;
// Mask for getting the lower bits for the in-index-2-block offset. */
const INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;
// Shift size for shifting left the index array values.
// Increases possible data size with 16-bit index values at the cost
// of compactability.
// This requires data blocks to be aligned by DATA_GRANULARITY.
const INDEX_SHIFT = 2;
// Number of entries in a data block. 32=0x20
const DATA_BLOCK_LENGTH = 1 << SHIFT_2;
// Mask for getting the lower bits for the in-data-block offset.
const DATA_MASK = DATA_BLOCK_LENGTH - 1;
// The part of the index-2 table for U+D800..U+DBFF stores values for
// lead surrogate code _units_ not code _points_.
// Values for lead surrogate code _points_ are indexed with this portion of the table.
// Length=32=0x20=0x400>>SHIFT_2. (There are 1024=0x400 lead surrogates.)
const LSCP_INDEX_2_OFFSET = 0x10000 >> SHIFT_2;
const LSCP_INDEX_2_LENGTH = 0x400 >> SHIFT_2;
// Count the lengths of both BMP pieces. 2080=0x820
const INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
// The 2-byte UTF-8 version of the index-2 table follows at offset 2080=0x820.
// Length 32=0x20 for lead bytes C0..DF, regardless of SHIFT_2.
const UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
const UTF8_2B_INDEX_2_LENGTH = 0x800 >> 6; // U+0800 is the first code point after 2-byte UTF-8
// The index-1 table, only used for supplementary code points, at offset 2112=0x840.
// Variable length, for code points up to highStart, where the last single-value range starts.
// Maximum length 512=0x200=0x100000>>SHIFT_1.
// (For 0x100000 supplementary code points U+10000..U+10ffff.)
//
// The part of the index-2 table for supplementary code points starts
// after this index-1 table.
//
// Both the index-1 table and the following part of the index-2 table
// are omitted completely if there is only BMP data.
const INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
// The alignment size of a data block. Also the granularity for compaction.
const DATA_GRANULARITY = 1 << INDEX_SHIFT;
class UnicodeTrie {
constructor(data) {
const isBuffer = (typeof data.readUInt32BE === 'function') && (typeof data.slice === 'function');
if (isBuffer || data instanceof Uint8Array) {
// read binary format
let uncompressedLength;
if (isBuffer) {
this.highStart = data.readUInt32LE(0);
this.errorValue = data.readUInt32LE(4);
uncompressedLength = data.readUInt32LE(8);
data = data.slice(12);
} else {
const view = new DataView(data.buffer);
this.highStart = view.getUint32(0, true);
this.errorValue = view.getUint32(4, true);
uncompressedLength = view.getUint32(8, true);
data = data.subarray(12);
}
// double inflate the actual trie data
data = inflate(data, new Uint8Array(uncompressedLength));
data = inflate(data, new Uint8Array(uncompressedLength));
// swap bytes from little-endian
swap32LE(data);
this.data = new Uint32Array(data.buffer);
} else {
// pre-parsed data
({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data);
}
}
get(codePoint) {
let index;
if ((codePoint < 0) || (codePoint > 0x10ffff)) {
return this.errorValue;
}
if ((codePoint < 0xd800) || ((codePoint > 0xdbff) && (codePoint <= 0xffff))) {
// Ordinary BMP code point, excluding leading surrogates.
// BMP uses a single level lookup. BMP index starts at offset 0 in the index.
// data is stored in the index array itself.
index = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index];
}
if (codePoint <= 0xffff) {
// Lead Surrogate Code Point. A Separate index section is stored for
// lead surrogate code units and code points.
// The main index has the code unit data.
// For this function, we need the code point data.
index = (this.data[LSCP_INDEX_2_OFFSET + ((codePoint - 0xd800) >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index];
}
if (codePoint < this.highStart) {
// Supplemental code point, use two-level lookup.
index = this.data[(INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH) + (codePoint >> SHIFT_1)];
index = this.data[index + ((codePoint >> SHIFT_2) & INDEX_2_MASK)];
index = (index << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index];
}
return this.data[this.data.length - DATA_GRANULARITY];
}
}
module.exports = UnicodeTrie;
},{"./swap":37,"tiny-inflate":33}],37:[function(require,module,exports){
const isBigEndian = (new Uint8Array(new Uint32Array([0x12345678]).buffer)[0] === 0x12);
const swap = (b, n, m) => {
let i = b[n];
b[n] = b[m];
b[m] = i;
};
const swap32 = array => {
const len = array.length;
for (let i = 0; i < len; i += 4) {
swap(array, i, i + 3);
swap(array, i + 1, i + 2);
}
};
const swap32LE = array => {
if (isBigEndian) {
swap32(array);
}
};
module.exports = {
swap32LE: swap32LE
};
},{}]},{},[1])(1)
});