diff --git a/credentials/html-render-method-pdfmake/README.md b/credentials/html-render-method-pdfmake/README.md new file mode 100644 index 0000000..a4ce3c7 --- /dev/null +++ b/credentials/html-render-method-pdfmake/README.md @@ -0,0 +1,28 @@ +# HTML Render Method Mustache Example VC + +This example contains an HTML-based template following the forthcoming +[HTML Render Method](https://github.com/w3c/vc-render-method/pull/42) +change to the +[Verifiable Credential Render Methods v1.0](https://w3c.github.io/vc-render-method/) +specification. + +It includes [Mustache.js](https://github.com/janl/mustache.js/) to handle +rendering within the HTML Render Method and [pdfmake](https://github.com/bpampuch/pdfmake) +to create a PDF from that HTML (well...text). + +Mustache.js and pdfmake must be injected into the HTML template which in turn +must be injected into the credential's render method. + +To do the above, the `./build.js` file is provided. If any changes are made to +the following files, `node ./build.js` must be rerun to update +`credential.json`: +* `./template.html` (the one most likely to be changed frequently) +* `./template-credential.json` (changes here might require changes to `./build.js`) +* `./mustache.v4.2.0.js` (updates to Mustache require changing `./build.js`) +* `./pdfmake.v0.3.8.js` (updates to pdfmake require changing `./build.js`) +* `./v3s_fonts.v0.3.8.js` (updates to vfs_fonts--used by pdfmake--require changing `./build.js`) + +## `image.png` Attribution + +The HTML file icon used in the `image.png` file was +[created by Smashicons and found via Flaticon.com](https://www.flaticon.com/free-icons/html-file). diff --git a/credentials/html-render-method-pdfmake/build.js b/credentials/html-render-method-pdfmake/build.js new file mode 100644 index 0000000..66a904e --- /dev/null +++ b/credentials/html-render-method-pdfmake/build.js @@ -0,0 +1,31 @@ +import fs from 'node:fs'; +import path from 'node:path'; + +// Load the raw Mustache code to inject into the HTML template +const mustachePath = path.join(import.meta.dirname, 'mustache.v4.2.0.js'); +const mustacheCode = fs.readFileSync(mustachePath, 'utf8'); +const pdfmakePath = path.join(import.meta.dirname, 'pdfmake.v0.3.8.js'); +const pdfmakeCode = fs.readFileSync(pdfmakePath, 'utf8'); +const vfsFontsPath = path.join(import.meta.dirname, 'vfs_fonts.v0.3.8.js'); +const vfsFontsCode = fs.readFileSync(vfsFontsPath, 'utf8'); + +// Load the HTML template to inject into the credential template +const htmlPath = path.join(import.meta.dirname, 'template.html'); +const htmlCode = fs.readFileSync(htmlPath, 'utf8'); +const htmlWithLibraries = ` + + + +${htmlCode}`; + +// add the SVG as the `template` value of the first `renderMethod` property +const credentialPath = path.join(import.meta.dirname, + 'template-credential.json'); +const credentialText = fs.readFileSync(credentialPath, 'utf8'); +const credential = JSON.parse(credentialText); +credential.renderMethod.template = + `data:text/html,${htmlWithLibraries}`; + +// Output the final credential +const outputPath = path.join(import.meta.dirname, 'credential.json'); +fs.writeFileSync(outputPath, JSON.stringify(credential, null, 2)); diff --git a/credentials/html-render-method-pdfmake/credential.json b/credentials/html-render-method-pdfmake/credential.json new file mode 100644 index 0000000..92c3573 --- /dev/null +++ b/credentials/html-render-method-pdfmake/credential.json @@ -0,0 +1,38 @@ +{ + "@context": [ + "https://www.w3.org/ns/credentials/v2", + "https://www.w3.org/ns/credentials/examples/v2" + ], + "type": [ + "VerifiableCredential", + "NameCredential" + ], + "issuer": { + "id": "did:example:1234", + "name": "The Issuer" + }, + "credentialSubject": { + "id": "did:example:ABCD", + "name": "Example Name", + "notRendered": "should not appear" + }, + "renderMethod": { + "type": "TemplateRenderMethod", + "renderSuite": "html", + "renderProperty": [ + "/issuer/name", + "/credentialSubject/name" + ], + "template": "data:text/html,\n\n\n\n
\n \n\n \n\n
\n

{{credentialSubject-name}}

\n

Issued by: {{ issuer-name }}

\n
\n
\n \n
\n", + "outputPreference": { + "mode": [ + "visual" + ], + "mediaType": "application/pdf", + "style": { + "width": "800px", + "height": "800px" + } + } + } +} \ No newline at end of file diff --git a/credentials/html-render-method-pdfmake/image.png b/credentials/html-render-method-pdfmake/image.png new file mode 100644 index 0000000..9809048 Binary files /dev/null and b/credentials/html-render-method-pdfmake/image.png differ diff --git a/credentials/html-render-method-pdfmake/mustache.v4.2.0.js b/credentials/html-render-method-pdfmake/mustache.v4.2.0.js new file mode 100644 index 0000000..66ff460 --- /dev/null +++ b/credentials/html-render-method-pdfmake/mustache.v4.2.0.js @@ -0,0 +1,775 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global = global || self, global.Mustache = factory()); +}(this, (function () { 'use strict'; + + /*! + * mustache.js - Logic-less {{mustache}} templates with JavaScript + * http://github.com/janl/mustache.js + */ + + var objectToString = Object.prototype.toString; + var isArray = Array.isArray || function isArrayPolyfill (object) { + return objectToString.call(object) === '[object Array]'; + }; + + function isFunction (object) { + return typeof object === 'function'; + } + + /** + * More correct typeof string handling array + * which normally returns typeof 'object' + */ + function typeStr (obj) { + return isArray(obj) ? 'array' : typeof obj; + } + + function escapeRegExp (string) { + return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&'); + } + + /** + * Null safe way of checking whether or not an object, + * including its prototype, has a given property + */ + function hasProperty (obj, propName) { + return obj != null && typeof obj === 'object' && (propName in obj); + } + + /** + * Safe way of detecting whether or not the given thing is a primitive and + * whether it has the given property + */ + function primitiveHasOwnProperty (primitive, propName) { + return ( + primitive != null + && typeof primitive !== 'object' + && primitive.hasOwnProperty + && primitive.hasOwnProperty(propName) + ); + } + + // Workaround for https://issues.apache.org/jira/browse/COUCHDB-577 + // See https://github.com/janl/mustache.js/issues/189 + var regExpTest = RegExp.prototype.test; + function testRegExp (re, string) { + return regExpTest.call(re, string); + } + + var nonSpaceRe = /\S/; + function isWhitespace (string) { + return !testRegExp(nonSpaceRe, string); + } + + var entityMap = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '/': '/', + '`': '`', + '=': '=' + }; + + function escapeHtml (string) { + return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap (s) { + return entityMap[s]; + }); + } + + var whiteRe = /\s*/; + var spaceRe = /\s+/; + var equalsRe = /\s*=/; + var curlyRe = /\s*\}/; + var tagRe = /#|\^|\/|>|\{|&|=|!/; + + /** + * Breaks up the given `template` string into a tree of tokens. If the `tags` + * argument is given here it must be an array with two string values: the + * opening and closing tags used in the template (e.g. [ "<%", "%>" ]). Of + * course, the default is to use mustaches (i.e. mustache.tags). + * + * A token is an array with at least 4 elements. The first element is the + * mustache symbol that was used inside the tag, e.g. "#" or "&". If the tag + * did not contain a symbol (i.e. {{myValue}}) this element is "name". For + * all text that appears outside a symbol this element is "text". + * + * The second element of a token is its "value". For mustache tags this is + * whatever else was inside the tag besides the opening symbol. For text tokens + * this is the text itself. + * + * The third and fourth elements of the token are the start and end indices, + * respectively, of the token in the original template. + * + * Tokens that are the root node of a subtree contain two more elements: 1) an + * array of tokens in the subtree and 2) the index in the original template at + * which the closing tag for that section begins. + * + * Tokens for partials also contain two more elements: 1) a string value of + * indendation prior to that tag and 2) the index of that tag on that line - + * eg a value of 2 indicates the partial is the third tag on this line. + */ + function parseTemplate (template, tags) { + if (!template) + return []; + var lineHasNonSpace = false; + var sections = []; // Stack to hold section tokens + var tokens = []; // Buffer to hold the tokens + var spaces = []; // Indices of whitespace tokens on the current line + var hasTag = false; // Is there a {{tag}} on the current line? + var nonSpace = false; // Is there a non-space char on the current line? + var indentation = ''; // Tracks indentation for tags that use it + var tagIndex = 0; // Stores a count of number of tags encountered on a line + + // Strips all whitespace tokens array for the current line + // if there was a {{#tag}} on it and otherwise only space. + function stripSpace () { + if (hasTag && !nonSpace) { + while (spaces.length) + delete tokens[spaces.pop()]; + } else { + spaces = []; + } + + hasTag = false; + nonSpace = false; + } + + var openingTagRe, closingTagRe, closingCurlyRe; + function compileTags (tagsToCompile) { + if (typeof tagsToCompile === 'string') + tagsToCompile = tagsToCompile.split(spaceRe, 2); + + if (!isArray(tagsToCompile) || tagsToCompile.length !== 2) + throw new Error('Invalid tags: ' + tagsToCompile); + + openingTagRe = new RegExp(escapeRegExp(tagsToCompile[0]) + '\\s*'); + closingTagRe = new RegExp('\\s*' + escapeRegExp(tagsToCompile[1])); + closingCurlyRe = new RegExp('\\s*' + escapeRegExp('}' + tagsToCompile[1])); + } + + compileTags(tags || mustache.tags); + + var scanner = new Scanner(template); + + var start, type, value, chr, token, openSection; + while (!scanner.eos()) { + start = scanner.pos; + + // Match any text between tags. + value = scanner.scanUntil(openingTagRe); + + if (value) { + for (var i = 0, valueLength = value.length; i < valueLength; ++i) { + chr = value.charAt(i); + + if (isWhitespace(chr)) { + spaces.push(tokens.length); + indentation += chr; + } else { + nonSpace = true; + lineHasNonSpace = true; + indentation += ' '; + } + + tokens.push([ 'text', chr, start, start + 1 ]); + start += 1; + + // Check for whitespace on the current line. + if (chr === '\n') { + stripSpace(); + indentation = ''; + tagIndex = 0; + lineHasNonSpace = false; + } + } + } + + // Match the opening tag. + if (!scanner.scan(openingTagRe)) + break; + + hasTag = true; + + // Get the tag type. + type = scanner.scan(tagRe) || 'name'; + scanner.scan(whiteRe); + + // Get the tag value. + if (type === '=') { + value = scanner.scanUntil(equalsRe); + scanner.scan(equalsRe); + scanner.scanUntil(closingTagRe); + } else if (type === '{') { + value = scanner.scanUntil(closingCurlyRe); + scanner.scan(curlyRe); + scanner.scanUntil(closingTagRe); + type = '&'; + } else { + value = scanner.scanUntil(closingTagRe); + } + + // Match the closing tag. + if (!scanner.scan(closingTagRe)) + throw new Error('Unclosed tag at ' + scanner.pos); + + if (type == '>') { + token = [ type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace ]; + } else { + token = [ type, value, start, scanner.pos ]; + } + tagIndex++; + tokens.push(token); + + if (type === '#' || type === '^') { + sections.push(token); + } else if (type === '/') { + // Check section nesting. + openSection = sections.pop(); + + if (!openSection) + throw new Error('Unopened section "' + value + '" at ' + start); + + if (openSection[1] !== value) + throw new Error('Unclosed section "' + openSection[1] + '" at ' + start); + } else if (type === 'name' || type === '{' || type === '&') { + nonSpace = true; + } else if (type === '=') { + // Set the tags for the next time around. + compileTags(value); + } + } + + stripSpace(); + + // Make sure there are no open sections when we're done. + openSection = sections.pop(); + + if (openSection) + throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos); + + return nestTokens(squashTokens(tokens)); + } + + /** + * Combines the values of consecutive text tokens in the given `tokens` array + * to a single token. + */ + function squashTokens (tokens) { + var squashedTokens = []; + + var token, lastToken; + for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) { + token = tokens[i]; + + if (token) { + if (token[0] === 'text' && lastToken && lastToken[0] === 'text') { + lastToken[1] += token[1]; + lastToken[3] = token[3]; + } else { + squashedTokens.push(token); + lastToken = token; + } + } + } + + return squashedTokens; + } + + /** + * Forms the given array of `tokens` into a nested tree structure where + * tokens that represent a section have two additional items: 1) an array of + * all tokens that appear in that section and 2) the index in the original + * template that represents the end of that section. + */ + function nestTokens (tokens) { + var nestedTokens = []; + var collector = nestedTokens; + var sections = []; + + var token, section; + for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) { + token = tokens[i]; + + switch (token[0]) { + case '#': + case '^': + collector.push(token); + sections.push(token); + collector = token[4] = []; + break; + case '/': + section = sections.pop(); + section[5] = token[2]; + collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens; + break; + default: + collector.push(token); + } + } + + return nestedTokens; + } + + /** + * A simple string scanner that is used by the template parser to find + * tokens in template strings. + */ + function Scanner (string) { + this.string = string; + this.tail = string; + this.pos = 0; + } + + /** + * Returns `true` if the tail is empty (end of string). + */ + Scanner.prototype.eos = function eos () { + return this.tail === ''; + }; + + /** + * Tries to match the given regular expression at the current position. + * Returns the matched text if it can match, the empty string otherwise. + */ + Scanner.prototype.scan = function scan (re) { + var match = this.tail.match(re); + + if (!match || match.index !== 0) + return ''; + + var string = match[0]; + + this.tail = this.tail.substring(string.length); + this.pos += string.length; + + return string; + }; + + /** + * Skips all text until the given regular expression can be matched. Returns + * the skipped string, which is the entire tail if no match can be made. + */ + Scanner.prototype.scanUntil = function scanUntil (re) { + var index = this.tail.search(re), match; + + switch (index) { + case -1: + match = this.tail; + this.tail = ''; + break; + case 0: + match = ''; + break; + default: + match = this.tail.substring(0, index); + this.tail = this.tail.substring(index); + } + + this.pos += match.length; + + return match; + }; + + /** + * Represents a rendering context by wrapping a view object and + * maintaining a reference to the parent context. + */ + function Context (view, parentContext) { + this.view = view; + this.cache = { '.': this.view }; + this.parent = parentContext; + } + + /** + * Creates a new context using the given view with this context + * as the parent. + */ + Context.prototype.push = function push (view) { + return new Context(view, this); + }; + + /** + * Returns the value of the given name in this context, traversing + * up the context hierarchy if the value is absent in this context's view. + */ + Context.prototype.lookup = function lookup (name) { + var cache = this.cache; + + var value; + if (cache.hasOwnProperty(name)) { + value = cache[name]; + } else { + var context = this, intermediateValue, names, index, lookupHit = false; + + while (context) { + if (name.indexOf('.') > 0) { + intermediateValue = context.view; + names = name.split('.'); + index = 0; + + /** + * Using the dot notion path in `name`, we descend through the + * nested objects. + * + * To be certain that the lookup has been successful, we have to + * check if the last object in the path actually has the property + * we are looking for. We store the result in `lookupHit`. + * + * This is specially necessary for when the value has been set to + * `undefined` and we want to avoid looking up parent contexts. + * + * In the case where dot notation is used, we consider the lookup + * to be successful even if the last "object" in the path is + * not actually an object but a primitive (e.g., a string, or an + * integer), because it is sometimes useful to access a property + * of an autoboxed primitive, such as the length of a string. + **/ + while (intermediateValue != null && index < names.length) { + if (index === names.length - 1) + lookupHit = ( + hasProperty(intermediateValue, names[index]) + || primitiveHasOwnProperty(intermediateValue, names[index]) + ); + + intermediateValue = intermediateValue[names[index++]]; + } + } else { + intermediateValue = context.view[name]; + + /** + * Only checking against `hasProperty`, which always returns `false` if + * `context.view` is not an object. Deliberately omitting the check + * against `primitiveHasOwnProperty` if dot notation is not used. + * + * Consider this example: + * ``` + * Mustache.render("The length of a football field is {{#length}}{{length}}{{/length}}.", {length: "100 yards"}) + * ``` + * + * If we were to check also against `primitiveHasOwnProperty`, as we do + * in the dot notation case, then render call would return: + * + * "The length of a football field is 9." + * + * rather than the expected: + * + * "The length of a football field is 100 yards." + **/ + lookupHit = hasProperty(context.view, name); + } + + if (lookupHit) { + value = intermediateValue; + break; + } + + context = context.parent; + } + + cache[name] = value; + } + + if (isFunction(value)) + value = value.call(this.view); + + return value; + }; + + /** + * A Writer knows how to take a stream of tokens and render them to a + * string, given a context. It also maintains a cache of templates to + * avoid the need to parse the same template twice. + */ + function Writer () { + this.templateCache = { + _cache: {}, + set: function set (key, value) { + this._cache[key] = value; + }, + get: function get (key) { + return this._cache[key]; + }, + clear: function clear () { + this._cache = {}; + } + }; + } + + /** + * Clears all cached templates in this writer. + */ + Writer.prototype.clearCache = function clearCache () { + if (typeof this.templateCache !== 'undefined') { + this.templateCache.clear(); + } + }; + + /** + * Parses and caches the given `template` according to the given `tags` or + * `mustache.tags` if `tags` is omitted, and returns the array of tokens + * that is generated from the parse. + */ + Writer.prototype.parse = function parse (template, tags) { + var cache = this.templateCache; + var cacheKey = template + ':' + (tags || mustache.tags).join(':'); + var isCacheEnabled = typeof cache !== 'undefined'; + var tokens = isCacheEnabled ? cache.get(cacheKey) : undefined; + + if (tokens == undefined) { + tokens = parseTemplate(template, tags); + isCacheEnabled && cache.set(cacheKey, tokens); + } + return tokens; + }; + + /** + * High-level method that is used to render the given `template` with + * the given `view`. + * + * The optional `partials` argument may be an object that contains the + * names and templates of partials that are used in the template. It may + * also be a function that is used to load partial templates on the fly + * that takes a single argument: the name of the partial. + * + * If the optional `config` argument is given here, then it should be an + * object with a `tags` attribute or an `escape` attribute or both. + * If an array is passed, then it will be interpreted the same way as + * a `tags` attribute on a `config` object. + * + * The `tags` attribute of a `config` object must be an array with two + * string values: the opening and closing tags used in the template (e.g. + * [ "<%", "%>" ]). The default is to mustache.tags. + * + * The `escape` attribute of a `config` object must be a function which + * accepts a string as input and outputs a safely escaped string. + * If an `escape` function is not provided, then an HTML-safe string + * escaping function is used as the default. + */ + Writer.prototype.render = function render (template, view, partials, config) { + var tags = this.getConfigTags(config); + var tokens = this.parse(template, tags); + var context = (view instanceof Context) ? view : new Context(view, undefined); + return this.renderTokens(tokens, context, partials, template, config); + }; + + /** + * Low-level method that renders the given array of `tokens` using + * the given `context` and `partials`. + * + * Note: The `originalTemplate` is only ever used to extract the portion + * of the original template that was contained in a higher-order section. + * If the template doesn't use higher-order sections, this argument may + * be omitted. + */ + Writer.prototype.renderTokens = function renderTokens (tokens, context, partials, originalTemplate, config) { + var buffer = ''; + + var token, symbol, value; + for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) { + value = undefined; + token = tokens[i]; + symbol = token[0]; + + if (symbol === '#') value = this.renderSection(token, context, partials, originalTemplate, config); + else if (symbol === '^') value = this.renderInverted(token, context, partials, originalTemplate, config); + else if (symbol === '>') value = this.renderPartial(token, context, partials, config); + else if (symbol === '&') value = this.unescapedValue(token, context); + else if (symbol === 'name') value = this.escapedValue(token, context, config); + else if (symbol === 'text') value = this.rawValue(token); + + if (value !== undefined) + buffer += value; + } + + return buffer; + }; + + Writer.prototype.renderSection = function renderSection (token, context, partials, originalTemplate, config) { + var self = this; + var buffer = ''; + var value = context.lookup(token[1]); + + // This function is used to render an arbitrary template + // in the current context by higher-order sections. + function subRender (template) { + return self.render(template, context, partials, config); + } + + if (!value) return; + + if (isArray(value)) { + for (var j = 0, valueLength = value.length; j < valueLength; ++j) { + buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config); + } + } else if (typeof value === 'object' || typeof value === 'string' || typeof value === 'number') { + buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config); + } else if (isFunction(value)) { + if (typeof originalTemplate !== 'string') + throw new Error('Cannot use higher-order sections without the original template'); + + // Extract the portion of the original template that the section contains. + value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender); + + if (value != null) + buffer += value; + } else { + buffer += this.renderTokens(token[4], context, partials, originalTemplate, config); + } + return buffer; + }; + + Writer.prototype.renderInverted = function renderInverted (token, context, partials, originalTemplate, config) { + var value = context.lookup(token[1]); + + // Use JavaScript's definition of falsy. Include empty arrays. + // See https://github.com/janl/mustache.js/issues/186 + if (!value || (isArray(value) && value.length === 0)) + return this.renderTokens(token[4], context, partials, originalTemplate, config); + }; + + Writer.prototype.indentPartial = function indentPartial (partial, indentation, lineHasNonSpace) { + var filteredIndentation = indentation.replace(/[^ \t]/g, ''); + var partialByNl = partial.split('\n'); + for (var i = 0; i < partialByNl.length; i++) { + if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) { + partialByNl[i] = filteredIndentation + partialByNl[i]; + } + } + return partialByNl.join('\n'); + }; + + Writer.prototype.renderPartial = function renderPartial (token, context, partials, config) { + if (!partials) return; + var tags = this.getConfigTags(config); + + var value = isFunction(partials) ? partials(token[1]) : partials[token[1]]; + if (value != null) { + var lineHasNonSpace = token[6]; + var tagIndex = token[5]; + var indentation = token[4]; + var indentedValue = value; + if (tagIndex == 0 && indentation) { + indentedValue = this.indentPartial(value, indentation, lineHasNonSpace); + } + var tokens = this.parse(indentedValue, tags); + return this.renderTokens(tokens, context, partials, indentedValue, config); + } + }; + + Writer.prototype.unescapedValue = function unescapedValue (token, context) { + var value = context.lookup(token[1]); + if (value != null) + return value; + }; + + Writer.prototype.escapedValue = function escapedValue (token, context, config) { + var escape = this.getConfigEscape(config) || mustache.escape; + var value = context.lookup(token[1]); + if (value != null) + return (typeof value === 'number' && escape === mustache.escape) ? String(value) : escape(value); + }; + + Writer.prototype.rawValue = function rawValue (token) { + return token[1]; + }; + + Writer.prototype.getConfigTags = function getConfigTags (config) { + if (isArray(config)) { + return config; + } + else if (config && typeof config === 'object') { + return config.tags; + } + else { + return undefined; + } + }; + + Writer.prototype.getConfigEscape = function getConfigEscape (config) { + if (config && typeof config === 'object' && !isArray(config)) { + return config.escape; + } + else { + return undefined; + } + }; + + var mustache = { + name: 'mustache.js', + version: '4.2.0', + tags: [ '{{', '}}' ], + clearCache: undefined, + escape: undefined, + parse: undefined, + render: undefined, + Scanner: undefined, + Context: undefined, + Writer: undefined, + /** + * Allows a user to override the default caching strategy, by providing an + * object with set, get and clear methods. This can also be used to disable + * the cache by setting it to the literal `undefined`. + */ + set templateCache (cache) { + defaultWriter.templateCache = cache; + }, + /** + * Gets the default or overridden caching object from the default writer. + */ + get templateCache () { + return defaultWriter.templateCache; + } + }; + + // All high-level mustache.* functions use this writer. + var defaultWriter = new Writer(); + + /** + * Clears all cached templates in the default writer. + */ + mustache.clearCache = function clearCache () { + return defaultWriter.clearCache(); + }; + + /** + * Parses and caches the given template in the default writer and returns the + * array of tokens it contains. Doing this ahead of time avoids the need to + * parse templates on the fly as they are rendered. + */ + mustache.parse = function parse (template, tags) { + return defaultWriter.parse(template, tags); + }; + + /** + * Renders the `template` with the given `view`, `partials`, and `config` + * using the default writer. + */ + mustache.render = function render (template, view, partials, config) { + if (typeof template !== 'string') { + throw new TypeError('Invalid template! Template should be a "string" ' + + 'but "' + typeStr(template) + '" was given as the first ' + + 'argument for mustache#render(template, view, partials)'); + } + + console.log('about to render...'); + const rendered = defaultWriter.render(template, view, partials, config); + console.log('rendered inside', rendered, view); + return rendered; + }; + + // Export the escaping function so that the user may override it. + // See https://github.com/janl/mustache.js/issues/244 + mustache.escape = escapeHtml; + + // Export these mainly for testing, but also for advanced usage. + mustache.Scanner = Scanner; + mustache.Context = Context; + mustache.Writer = Writer; + + return mustache; + +}))); diff --git a/credentials/html-render-method-pdfmake/pdfmake.v0.3.8.js b/credentials/html-render-method-pdfmake/pdfmake.v0.3.8.js new file mode 100644 index 0000000..70938d4 --- /dev/null +++ b/credentials/html-render-method-pdfmake/pdfmake.v0.3.8.js @@ -0,0 +1,65803 @@ +/*! pdfmake v0.3.8, @license MIT, @link http://pdfmake.org */ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define([], factory); + else { + var a = factory(); + for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i]; + } +})(Object(typeof self !== 'undefined' ? self : this), () => { +return /******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ 7133 +(__unused_webpack_module, __webpack_exports__, __webpack_require__) { + +"use strict"; + +// EXPORTS +__webpack_require__.d(__webpack_exports__, { + "default": () => (/* binding */ browser_extensions) +}); + +// EXTERNAL MODULE: ./node_modules/core-js/modules/es.array.includes.js +var es_array_includes = __webpack_require__(187); +// EXTERNAL MODULE: ./node_modules/pdfkit/js/pdfkit.es.js +var pdfkit_es = __webpack_require__(3215); +;// ./src/helpers/variableType.js +/** + * @param {any} variable + * @returns {boolean} + */ +function isString(variable) { + return typeof variable === 'string' || variable instanceof String; +} + +/** + * @param {any} variable + * @returns {boolean} + */ +function isNumber(variable) { + return (typeof variable === 'number' || variable instanceof Number) && !Number.isNaN(variable); +} + +/** + * @param {any} variable + * @returns {boolean} + */ +function isPositiveInteger(variable) { + if (!isNumber(variable) || !Number.isInteger(variable) || variable <= 0) { + return false; + } + return true; +} + +/** + * @param {any} variable + * @returns {boolean} + */ +function isObject(variable) { + return variable !== null && !Array.isArray(variable) && !isString(variable) && !isNumber(variable) && typeof variable === 'object'; +} + +/** + * @param {any} variable + * @returns {boolean} + */ +function isEmptyObject(variable) { + return isObject(variable) && Object.keys(variable).length === 0; +} + +/** + * @param {any} variable + * @returns {boolean} + */ +function isValue(variable) { + return variable !== undefined && variable !== null; +} +;// ./src/PDFDocument.js +/* provided dependency */ var Buffer = __webpack_require__(783)["Buffer"]; + + +const typeName = (bold, italics) => { + let type = 'normal'; + if (bold && italics) { + type = 'bolditalics'; + } else if (bold) { + type = 'bold'; + } else if (italics) { + type = 'italics'; + } + return type; +}; +class PDFDocument extends pdfkit_es/* default */.A { + constructor(fonts, images, patterns, attachments, options, virtualfs, localAccessPolicy) { + if (fonts === void 0) { + fonts = {}; + } + if (images === void 0) { + images = {}; + } + if (patterns === void 0) { + patterns = {}; + } + if (attachments === void 0) { + attachments = {}; + } + if (options === void 0) { + options = {}; + } + if (virtualfs === void 0) { + virtualfs = null; + } + if (localAccessPolicy === void 0) { + localAccessPolicy = undefined; + } + super(options); + this.fonts = {}; + this.fontCache = {}; + for (let font in fonts) { + if (fonts.hasOwnProperty(font)) { + let fontDef = fonts[font]; + this.fonts[font] = { + normal: fontDef.normal, + bold: fontDef.bold, + italics: fontDef.italics, + bolditalics: fontDef.bolditalics + }; + } + } + this.patterns = {}; + for (let pattern in patterns) { + if (patterns.hasOwnProperty(pattern)) { + let patternDef = patterns[pattern]; + this.patterns[pattern] = this.pattern(patternDef.boundingBox, patternDef.xStep, patternDef.yStep, patternDef.pattern, patternDef.colored); + } + } + this.images = images; + this.attachments = attachments; + this.virtualfs = virtualfs; + this.localAccessPolicy = localAccessPolicy; + } + getFontType(bold, italics) { + return typeName(bold, italics); + } + getFontFile(familyName, bold, italics) { + let type = this.getFontType(bold, italics); + if (!this.fonts[familyName] || !this.fonts[familyName][type]) { + return null; + } + return this.fonts[familyName][type]; + } + provideFont(familyName, bold, italics) { + let type = this.getFontType(bold, italics); + if (this.getFontFile(familyName, bold, italics) === null) { + throw new Error(`Font '${familyName}' in style '${type}' is not defined in the font section of the document definition.`); + } + this.fontCache[familyName] = this.fontCache[familyName] || {}; + if (!this.fontCache[familyName][type]) { + let def = this.fonts[familyName][type]; + if (!Array.isArray(def)) { + def = [def]; + } + if (this.virtualfs && this.virtualfs.existsSync(def[0])) { + def[0] = this.virtualfs.readFileSync(def[0]); + } else { + this.validateLocalFile(def[0]); + } + this.fontCache[familyName][type] = this.font(...def)._font; + } + return this.fontCache[familyName][type]; + } + provideImage(src) { + const realImageSrc = src => { + let image = this.images[src]; + if (!image) { + return src; + } + if (this.virtualfs && this.virtualfs.existsSync(image)) { + return this.virtualfs.readFileSync(image); + } + let index = image.indexOf('base64,'); + if (index < 0) { + return this.images[src]; + } + return Buffer.from(image.substring(index + 7), 'base64'); + }; + if (this._imageRegistry[src]) { + return this._imageRegistry[src]; + } + let image; + let imageSrc = realImageSrc(src); + this.validateLocalFile(imageSrc); + try { + image = this.openImage(imageSrc); + if (!image) { + throw new Error('No image'); + } + } catch (error) { + throw new Error(`Invalid image: ${error.toString()}\nImages dictionary should contain dataURL entries (or local file paths in node.js)`, { + cause: error + }); + } + image.embed(this); + this._imageRegistry[src] = image; + return image; + } + + /** + * @param {Array} color pdfmake format: [, ] + * @returns {Array} pdfkit format: [, ] + */ + providePattern(color) { + if (Array.isArray(color) && color.length === 2) { + return [this.patterns[color[0]], color[1]]; + } + return null; + } + provideAttachment(src) { + const checkRequired = obj => { + if (!obj) { + throw new Error('No attachment'); + } + if (!obj.src) { + throw new Error('The "src" key is required for attachments'); + } + return obj; + }; + if (typeof src === 'object') { + return checkRequired(src); + } + let attachment = checkRequired(this.attachments[src]); + if (this.virtualfs && this.virtualfs.existsSync(attachment.src)) { + return this.virtualfs.readFileSync(attachment.src); + } + this.validateLocalFile(attachment.src); + return attachment; + } + resolveColor(color, defaultColor) { + color = color || defaultColor; + if (typeof this._normalizeColor === 'function') { + if (isString(color) && this._normalizeColor(color) === null) { + // color is not valid + return defaultColor; + } + } + return color; + } + setOpenActionAsPrint() { + let printActionRef = this.ref({ + Type: 'Action', + S: 'Named', + N: 'Print' + }); + this._root.data.OpenAction = printActionRef; + printActionRef.end(); + } + file(src, options) { + if (options === void 0) { + options = {}; + } + this.validateLocalFile(src); + return super.file(src, options); + } + validateLocalFile(path) { + if (typeof this.localAccessPolicy === 'undefined') { + return; + } + if (!isString(path)) { + return; + } + if (/^data:/.test(path)) { + return; + } + if (this.localAccessPolicy(path) !== true) { + throw new Error(`Access to local file denied by resource access policy: ${path}`); + } + } +} +/* harmony default export */ const src_PDFDocument = (PDFDocument); +;// ./src/helpers/node.js + +function fontStringify(key, val) { + if (key === 'font') { + return 'font'; + } + return val; +} + +/** + * Convert node to readable string + * + * @param {object} node + * @returns {string} + */ +function stringifyNode(node) { + return JSON.stringify(node, fontStringify); +} + +/** + * @param {object} node + * @returns {?string} + */ +function getNodeId(node) { + if (node.id) { + return node.id; + } + if (Array.isArray(node.text)) { + for (let n of node.text) { + let nodeId = getNodeId(n); + if (nodeId) { + return nodeId; + } + } + } + return null; +} + +/** + * @param {object} node + * @param {object} styleStack object is instance of PDFDocument + * @returns {?Array} + */ +function getNodeMargin(node, styleStack) { + function processSingleMargins(node, currentMargin, defaultMargin) { + if (defaultMargin === void 0) { + defaultMargin = 0; + } + if (node.marginLeft !== undefined || node.marginTop !== undefined || node.marginRight !== undefined || node.marginBottom !== undefined) { + return [node.marginLeft ?? currentMargin[0] ?? defaultMargin, node.marginTop ?? currentMargin[1] ?? defaultMargin, node.marginRight ?? currentMargin[2] ?? defaultMargin, node.marginBottom ?? currentMargin[3] ?? defaultMargin]; + } + return currentMargin; + } + function flattenStyleArray(styleArray, styleStack, visited) { + if (visited === void 0) { + visited = new Set(); + } + styleArray = Array.isArray(styleArray) ? styleArray : [styleArray]; + + // style is not valid array of strings + if (!styleArray.every(item => isString(item))) { + return {}; + } + let flattenedStyles = {}; + for (let index = 0; index < styleArray.length; index++) { + let styleName = styleArray[index]; + let style = styleStack.styleDictionary[styleName]; + + // style not found + if (style === undefined) { + continue; + } + if (visited.has(styleName)) { + continue; + } + if (style.extends !== undefined) { + flattenedStyles = { + ...flattenedStyles, + ...flattenStyleArray(style.extends, styleStack, new Set([...visited, styleName])) + }; + } + if (style.margin !== undefined) { + flattenedStyles = { + margin: convertMargin(style.margin) + }; + continue; + } + flattenedStyles = { + margin: processSingleMargins(style, flattenedStyles.margin ?? {}, undefined) + }; + } + return flattenedStyles; + } + function convertMargin(margin) { + if (isNumber(margin)) { + margin = [margin, margin, margin, margin]; + } else if (Array.isArray(margin)) { + if (margin.length === 2) { + margin = [margin[0], margin[1], margin[0], margin[1]]; + } + } + return margin; + } + let margin = [undefined, undefined, undefined, undefined]; + if (node.style) { + let styleArray = Array.isArray(node.style) ? node.style : [node.style]; + let flattenedStyleArray = flattenStyleArray(styleArray, styleStack); + if (flattenedStyleArray) { + margin = processSingleMargins(flattenedStyleArray, margin); + } + if (flattenedStyleArray.margin) { + margin = convertMargin(flattenedStyleArray.margin); + } + } + margin = processSingleMargins(node, margin); + if (node.margin !== undefined) { + margin = convertMargin(node.margin); + } + if (margin[0] === undefined && margin[1] === undefined && margin[2] === undefined && margin[3] === undefined) { + return null; + } + return margin; +} +;// ./src/DocPreprocessor.js +/* provided dependency */ var DocPreprocessor_Buffer = __webpack_require__(783)["Buffer"]; + + +const convertValueToString = value => { + if (isString(value)) { + return value.replace(/\t/g, ' '); // expand tab as spaces + } else if (isNumber(value) || typeof value === 'boolean') { + return value.toString(); + } else if (!isValue(value) || isEmptyObject(value)) { + return ''; + } + + // TODO: throw exception ? + + return value; +}; +class DocPreprocessor { + preprocessDocument(docStructure) { + this.parentNode = null; + this.tocs = []; + this.nodeReferences = []; + return this.preprocessNode(docStructure, true); + } + preprocessBlock(node) { + this.parentNode = null; + this.tocs = []; + this.nodeReferences = []; + return this.preprocessNode(node); + } + preprocessNode(node, isSectionAllowed) { + if (isSectionAllowed === void 0) { + isSectionAllowed = false; + } + // expand shortcuts and casting values + if (Array.isArray(node)) { + node = { + stack: node + }; + } else if (isString(node) || isNumber(node) || typeof node === 'boolean' || !isValue(node) || isEmptyObject(node)) { + // text node defined as value + node = { + text: convertValueToString(node) + }; + } else if ('text' in node) { + // cast value in text property + node.text = convertValueToString(node.text); + } + if (node.section) { + if (!isSectionAllowed) { + throw new Error(`Incorrect document structure, section node is only allowed at the root level of document structure: ${stringifyNode(node)}`); + } + return this.preprocessSection(node); + } else if (node.columns) { + return this.preprocessColumns(node); + } else if (node.stack) { + return this.preprocessVerticalContainer(node, isSectionAllowed); + } else if (node.ul) { + return this.preprocessList(node); + } else if (node.ol) { + return this.preprocessList(node); + } else if (node.table) { + return this.preprocessTable(node); + } else if (node.text !== undefined) { + return this.preprocessText(node); + } else if (node.toc) { + return this.preprocessToc(node); + } else if (node.image) { + return this.preprocessImage(node); + } else if (node.svg) { + return this.preprocessSVG(node); + } else if (node.canvas) { + return this.preprocessCanvas(node); + } else if (node.qr) { + return this.preprocessQr(node); + } else if (node.attachment) { + return this.preprocessAttachment(node); + } else if (node.pageReference || node.textReference) { + return this.preprocessText(node); + } else { + throw new Error(`Unrecognized document structure: ${stringifyNode(node)}`); + } + } + preprocessSection(node) { + node.section = this.preprocessNode(node.section); + return node; + } + preprocessColumns(node) { + let columns = node.columns; + for (let i = 0, l = columns.length; i < l; i++) { + columns[i] = this.preprocessNode(columns[i]); + } + return node; + } + preprocessVerticalContainer(node, isSectionAllowed) { + let items = node.stack; + for (let i = 0, l = items.length; i < l; i++) { + items[i] = this.preprocessNode(items[i], isSectionAllowed); + } + return node; + } + preprocessList(node) { + let items = node.ul || node.ol; + for (let i = 0, l = items.length; i < l; i++) { + items[i] = this.preprocessNode(items[i]); + } + return node; + } + preprocessTable(node) { + let col; + let row; + let cols; + let rows; + for (col = 0, cols = node.table.body[0].length; col < cols; col++) { + for (row = 0, rows = node.table.body.length; row < rows; row++) { + let rowData = node.table.body[row]; + let data = rowData[col]; + if (data !== undefined) { + if (data === null) { + // transform to object + data = ''; + } + if (!data._span) { + rowData[col] = this.preprocessNode(data); + } + } + } + } + return node; + } + preprocessText(node) { + if (node.tocItem) { + if (!Array.isArray(node.tocItem)) { + node.tocItem = [node.tocItem]; + } + for (let i = 0, l = node.tocItem.length; i < l; i++) { + if (!isString(node.tocItem[i])) { + node.tocItem[i] = '_default_'; + } + let tocItemId = node.tocItem[i]; + if (!this.tocs[tocItemId]) { + this.tocs[tocItemId] = { + toc: { + _items: [], + _pseudo: true + } + }; + } + if (!node.id) { + node.id = `toc-${tocItemId}-${this.tocs[tocItemId].toc._items.length}`; + } + let tocItemRef = { + _nodeRef: this._getNodeForNodeRef(node), + _textNodeRef: node + }; + this.tocs[tocItemId].toc._items.push(tocItemRef); + } + } + if (node.id) { + if (this.nodeReferences[node.id]) { + if (!this.nodeReferences[node.id]._pseudo) { + throw new Error(`Node id '${node.id}' already exists`); + } + this.nodeReferences[node.id]._nodeRef = this._getNodeForNodeRef(node); + this.nodeReferences[node.id]._textNodeRef = node; + this.nodeReferences[node.id]._pseudo = false; + } else { + this.nodeReferences[node.id] = { + _nodeRef: this._getNodeForNodeRef(node), + _textNodeRef: node + }; + } + } + if (node.pageReference) { + if (!this.nodeReferences[node.pageReference]) { + this.nodeReferences[node.pageReference] = { + _nodeRef: {}, + _textNodeRef: {}, + _pseudo: true + }; + } + node.text = '00000'; + node.linkToDestination = node.pageReference; + node._pageRef = this.nodeReferences[node.pageReference]; + } + if (node.textReference) { + if (!this.nodeReferences[node.textReference]) { + this.nodeReferences[node.textReference] = { + _nodeRef: {}, + _pseudo: true + }; + } + node.text = ''; + node.linkToDestination = node.textReference; + node._textRef = this.nodeReferences[node.textReference]; + } + if (node.text && node.text.text) { + node.text = [this.preprocessNode(node.text)]; + } else if (Array.isArray(node.text)) { + let isSetParentNode = false; + if (this.parentNode === null) { + this.parentNode = node; + isSetParentNode = true; + } + for (let i = 0, l = node.text.length; i < l; i++) { + node.text[i] = this.preprocessNode(node.text[i]); + } + if (isSetParentNode) { + this.parentNode = null; + } + } + return node; + } + preprocessToc(node) { + if (!node.toc.id) { + node.toc.id = '_default_'; + } + node.toc.title = node.toc.title ? this.preprocessNode(node.toc.title) : null; + node.toc._items = []; + if (this.tocs[node.toc.id]) { + if (!this.tocs[node.toc.id].toc._pseudo) { + throw new Error(`TOC '${node.toc.id}' already exists`); + } + node.toc._items = this.tocs[node.toc.id].toc._items; + } + this.tocs[node.toc.id] = node; + return node; + } + preprocessImage(node) { + if (node.image.type !== undefined && node.image.data !== undefined && node.image.type === 'Buffer' && Array.isArray(node.image.data)) { + node.image = DocPreprocessor_Buffer.from(node.image.data); + } + return node; + } + preprocessCanvas(node) { + return node; + } + preprocessSVG(node) { + return node; + } + preprocessQr(node) { + return node; + } + preprocessAttachment(node) { + return node; + } + _getNodeForNodeRef(node) { + if (this.parentNode) { + return this.parentNode; + } + return node; + } +} +/* harmony default export */ const src_DocPreprocessor = (DocPreprocessor); +// EXTERNAL MODULE: ./node_modules/unicode-trie/index.js +var unicode_trie = __webpack_require__(7571); +// EXTERNAL MODULE: ./node_modules/linebreak/node_modules/base64-js/lib/b64.js +var b64 = __webpack_require__(3915); +;// ./node_modules/linebreak/dist/module.mjs + + + +var $557adaaeb0c7885f$exports = {}; + +"use strict"; + + + +const $1627905f8be2ef3f$export$af862512e23cb54 = 0; // Opening punctuation +const $1627905f8be2ef3f$export$9bf3043cb7503aa1 = 1; // Closing punctuation +const $1627905f8be2ef3f$export$6d0b2a5dd774590a = 2; // Closing parenthesis +const $1627905f8be2ef3f$export$bf0b2277bd569ea1 = 3; // Ambiguous quotation +const $1627905f8be2ef3f$export$bad2a840ccda93b6 = 4; // Glue +const $1627905f8be2ef3f$export$fb4028874a74450 = 5; // Non-starters +const $1627905f8be2ef3f$export$463bd1ce0149c55e = 6; // Exclamation/Interrogation +const $1627905f8be2ef3f$export$2e8caadc521d7cbb = 7; // Symbols allowing break after +const $1627905f8be2ef3f$export$bfe27467c1de9413 = 8; // Infix separator +const $1627905f8be2ef3f$export$af5f8d68aad3cd3a = 9; // Prefix +const $1627905f8be2ef3f$export$6b7e017d6825d38f = 10; // Postfix +const $1627905f8be2ef3f$export$8227ca023eb0daaa = 11; // Numeric +const $1627905f8be2ef3f$export$1bb1140fe1358b00 = 12; // Alphabetic +const $1627905f8be2ef3f$export$f3e416a182673355 = 13; // Hebrew Letter +const $1627905f8be2ef3f$export$8be180ec26319f9f = 14; // Ideographic +const $1627905f8be2ef3f$export$70824c8942178d60 = 15; // Inseparable characters +const $1627905f8be2ef3f$export$24aa617c849a894a = 16; // Hyphen +const $1627905f8be2ef3f$export$a73c4d14459b698d = 17; // Break after +const $1627905f8be2ef3f$export$921068d8846a1559 = 18; // Break before +const $1627905f8be2ef3f$export$8b85a4f193482778 = 19; // Break on either side (but not pair) +const $1627905f8be2ef3f$export$b2fd9c01d360241f = 20; // Zero-width space +const $1627905f8be2ef3f$export$dcd191669c0a595f = 21; // Combining marks +const $1627905f8be2ef3f$export$9e5d732f3676a9ba = 22; // Word joiner +const $1627905f8be2ef3f$export$cb94397127ac9363 = 23; // Hangul LV +const $1627905f8be2ef3f$export$746be9e3a3dfff1f = 24; // Hangul LVT +const $1627905f8be2ef3f$export$96e3e682276c47cf = 25; // Hangul L Jamo +const $1627905f8be2ef3f$export$fc2ff69ee2cb01bf = 26; // Hangul V Jamo +const $1627905f8be2ef3f$export$8999624a7bae9d04 = 27; // Hangul T Jamo +const $1627905f8be2ef3f$export$1dff41d5c0caca01 = 28; // Regional Indicator +const $1627905f8be2ef3f$export$ddb7a6c76d9d93eb = 29; // Emoji Base +const $1627905f8be2ef3f$export$7e93eb3105e4786d = 30; // Emoji Modifier +const $1627905f8be2ef3f$export$30a74a373318dec6 = 31; // Zero Width Joiner +const $1627905f8be2ef3f$export$54caeea5e6dab1f = 32; // Contingent break +const $1627905f8be2ef3f$export$d710c5f50fc7496a = 33; // Ambiguous (Alphabetic or Ideograph) +const $1627905f8be2ef3f$export$66498d28055820a9 = 34; // Break (mandatory) +const $1627905f8be2ef3f$export$eb6c6d0b7c8826f2 = 35; // Conditional Japanese Starter +const $1627905f8be2ef3f$export$de92be486109a1df = 36; // Carriage return +const $1627905f8be2ef3f$export$606cfc2a8896c91f = 37; // Line feed +const $1627905f8be2ef3f$export$e51d3c675bb0140d = 38; // Next line +const $1627905f8be2ef3f$export$da51c6332ad11d7b = 39; // South-East Asian +const $1627905f8be2ef3f$export$bea437c40441867d = 40; // Surrogates +const $1627905f8be2ef3f$export$c4c7eecbfed13dc9 = 41; // Space +const $1627905f8be2ef3f$export$98e1f8a379849661 = 42; // Unknown + + +const $32627af916ac1b00$export$98f50d781a474745 = 0; // Direct break opportunity +const $32627af916ac1b00$export$12ee1f8f5315ca7e = 1; // Indirect break opportunity +const $32627af916ac1b00$export$e4965ce242860454 = 2; // Indirect break opportunity for combining marks +const $32627af916ac1b00$export$8f14048969dcd45e = 3; // Prohibited break for combining marks +const $32627af916ac1b00$export$133eb141bf58aff4 = 4; // Prohibited break +const $32627af916ac1b00$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 + [ + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$8f14048969dcd45e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ], + [ + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$e4965ce242860454, + $32627af916ac1b00$export$133eb141bf58aff4, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$98f50d781a474745, + $32627af916ac1b00$export$12ee1f8f5315ca7e, + $32627af916ac1b00$export$98f50d781a474745 + ] // CB +]; + + +const $557adaaeb0c7885f$var$data = b64.toByteArray("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"); +const $557adaaeb0c7885f$var$classTrie = new unicode_trie($557adaaeb0c7885f$var$data); +const $557adaaeb0c7885f$var$mapClass = function(c) { + switch(c){ + case $1627905f8be2ef3f$export$d710c5f50fc7496a: + return $1627905f8be2ef3f$export$1bb1140fe1358b00; + case $1627905f8be2ef3f$export$da51c6332ad11d7b: + case $1627905f8be2ef3f$export$bea437c40441867d: + case $1627905f8be2ef3f$export$98e1f8a379849661: + return $1627905f8be2ef3f$export$1bb1140fe1358b00; + case $1627905f8be2ef3f$export$eb6c6d0b7c8826f2: + return $1627905f8be2ef3f$export$fb4028874a74450; + default: + return c; + } +}; +const $557adaaeb0c7885f$var$mapFirst = function(c) { + switch(c){ + case $1627905f8be2ef3f$export$606cfc2a8896c91f: + case $1627905f8be2ef3f$export$e51d3c675bb0140d: + return $1627905f8be2ef3f$export$66498d28055820a9; + case $1627905f8be2ef3f$export$c4c7eecbfed13dc9: + return $1627905f8be2ef3f$export$9e5d732f3676a9ba; + default: + return c; + } +}; +class $557adaaeb0c7885f$var$Break { + constructor(position, required = false){ + this.position = position; + this.required = required; + } +} +class $557adaaeb0c7885f$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 $557adaaeb0c7885f$var$mapClass($557adaaeb0c7885f$var$classTrie.get(this.nextCodePoint())); + } + getSimpleBreak() { + // handle classes not handled by the pair table + switch(this.nextClass){ + case $1627905f8be2ef3f$export$c4c7eecbfed13dc9: + return false; + case $1627905f8be2ef3f$export$66498d28055820a9: + case $1627905f8be2ef3f$export$606cfc2a8896c91f: + case $1627905f8be2ef3f$export$e51d3c675bb0140d: + this.curClass = $1627905f8be2ef3f$export$66498d28055820a9; + return false; + case $1627905f8be2ef3f$export$de92be486109a1df: + this.curClass = $1627905f8be2ef3f$export$de92be486109a1df; + return false; + } + return null; + } + getPairTableBreak(lastClass) { + // if not handled already, use the pair table + let shouldBreak = false; + switch($32627af916ac1b00$export$5bdb8ccbf5c57afc[this.curClass][this.nextClass]){ + case $32627af916ac1b00$export$98f50d781a474745: + shouldBreak = true; + break; + case $32627af916ac1b00$export$12ee1f8f5315ca7e: + shouldBreak = lastClass === $1627905f8be2ef3f$export$c4c7eecbfed13dc9; + break; + case $32627af916ac1b00$export$e4965ce242860454: + shouldBreak = lastClass === $1627905f8be2ef3f$export$c4c7eecbfed13dc9; + if (!shouldBreak) { + shouldBreak = false; + return shouldBreak; + } + break; + case $32627af916ac1b00$export$8f14048969dcd45e: + if (lastClass !== $1627905f8be2ef3f$export$c4c7eecbfed13dc9) return shouldBreak; + break; + case $32627af916ac1b00$export$133eb141bf58aff4: + break; + } + if (this.LB8a) shouldBreak = false; + // Rule LB21a + if (this.LB21a && (this.curClass === $1627905f8be2ef3f$export$24aa617c849a894a || this.curClass === $1627905f8be2ef3f$export$a73c4d14459b698d)) { + shouldBreak = false; + this.LB21a = false; + } else this.LB21a = this.curClass === $1627905f8be2ef3f$export$f3e416a182673355; + // Rule LB30a + if (this.curClass === $1627905f8be2ef3f$export$1dff41d5c0caca01) { + this.LB30a++; + if (this.LB30a == 2 && this.nextClass === $1627905f8be2ef3f$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 = $557adaaeb0c7885f$var$mapFirst(firstClass); + this.nextClass = firstClass; + this.LB8a = firstClass === $1627905f8be2ef3f$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 === $1627905f8be2ef3f$export$66498d28055820a9 || this.curClass === $1627905f8be2ef3f$export$de92be486109a1df && this.nextClass !== $1627905f8be2ef3f$export$606cfc2a8896c91f) { + this.curClass = $557adaaeb0c7885f$var$mapFirst($557adaaeb0c7885f$var$mapClass(this.nextClass)); + return new $557adaaeb0c7885f$var$Break(this.lastPos, true); + } + let shouldBreak = this.getSimpleBreak(); + if (shouldBreak === null) shouldBreak = this.getPairTableBreak(lastClass); + // Rule LB8a + this.LB8a = this.nextClass === $1627905f8be2ef3f$export$30a74a373318dec6; + if (shouldBreak) return new $557adaaeb0c7885f$var$Break(this.lastPos); + } + if (this.lastPos < this.string.length) { + this.lastPos = this.string.length; + return new $557adaaeb0c7885f$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; + } +} +$557adaaeb0c7885f$exports = $557adaaeb0c7885f$var$LineBreaker; + + + +//# sourceMappingURL=module.mjs.map + +;// ./src/StyleContextStack.js + + +/** + * Used for style inheritance and style overrides + */ +class StyleContextStack { + /** + * @param {object} styleDictionary named styles dictionary + * @param {object} defaultStyle optional default style definition + */ + constructor(styleDictionary, defaultStyle) { + if (defaultStyle === void 0) { + defaultStyle = {}; + } + this.styleDictionary = styleDictionary; + this.defaultStyle = defaultStyle; + this.styleOverrides = []; + } + + /** + * Creates cloned version of current stack + * + * @returns {StyleContextStack} current stack snapshot + */ + clone() { + let stack = new StyleContextStack(this.styleDictionary, this.defaultStyle); + this.styleOverrides.forEach(item => { + stack.styleOverrides.push(item); + }); + return stack; + } + + /** + * Pushes style-name or style-overrides-object onto the stack for future evaluation + * + * @param {string|object} styleNameOrOverride style-name (referring to styleDictionary) or + * a new dictionary defining overriding properties + */ + push(styleNameOrOverride) { + this.styleOverrides.push(styleNameOrOverride); + } + + /** + * Removes last style-name or style-overrides-object from the stack + * + * @param {number} howMany optional number of elements to be popped (if not specified, + * one element will be removed from the stack) + */ + pop(howMany) { + if (howMany === void 0) { + howMany = 1; + } + while (howMany-- > 0) { + this.styleOverrides.pop(); + } + } + + /** + * Creates a set of named styles or/and a style-overrides-object based on the item, + * pushes those elements onto the stack for future evaluation and returns the number + * of elements pushed, so they can be easily popped then. + * + * @param {object} item - an object with optional style property and/or style overrides + * @returns {number} the number of items pushed onto the stack + */ + autopush(item) { + if (isString(item)) { + return 0; + } + if (typeof item.section !== 'undefined') { + // section node not support style overrides + return 0; + } + let styleNames = []; + if (item.style) { + if (Array.isArray(item.style)) { + styleNames = item.style; + } else { + styleNames = [item.style]; + } + } + for (let i = 0, l = styleNames.length; i < l; i++) { + this.push(styleNames[i]); + } + + // rather than spend significant time making a styleOverrideObject, just add item + this.push(item); + return styleNames.length + 1; + } + + /** + * Automatically pushes elements onto the stack, using autopush based on item, + * executes callback and then pops elements back. Returns value returned by callback + * + * @param {object} item - an object with optional style property and/or style overrides + * @param {Function} callback to be called between autopush and pop + * @returns {object} value returned by callback + */ + auto(item, callback) { + let pushedItems = this.autopush(item); + let result = callback(); + if (pushedItems > 0) { + this.pop(pushedItems); + } + return result; + } + + /** + * Evaluates stack and returns value of a named property + * + * @param {string} property - property name + * @returns {?any} property value or null if not found + */ + getProperty(property) { + var _this = this; + const getStylePropertyFromStyle = function (styleName, property, visited) { + if (visited === void 0) { + visited = new Set(); + } + if (visited.has(styleName)) { + return undefined; + } + visited.add(styleName); + const style = _this.styleDictionary[styleName]; + if (!style) { + return undefined; + } + if (isValue(style[property])) { + return style[property]; + } + if (style.extends) { + let parents = Array.isArray(style.extends) ? style.extends : [style.extends]; + for (let i = parents.length - 1; i >= 0; i--) { + let value = getStylePropertyFromStyle(parents[i], property, visited); + if (isValue(value)) { + return value; + } + } + } + return undefined; + }; + if (this.styleOverrides) { + for (let i = this.styleOverrides.length - 1; i >= 0; i--) { + let item = this.styleOverrides[i]; + if (isString(item)) { + // named-style-override + let value = getStylePropertyFromStyle(item, property); + if (isValue(value)) { + return value; + } + } else if (isValue(item[property])) { + // style-overrides-object + return item[property]; + } + } + } + return this.defaultStyle && this.defaultStyle[property]; + } + + /** + * @param {object} item + * @param {StyleContextStack} styleContextStack + * @param {string} property + * @param {any} defaultValue + * @returns {any} + */ + static getStyleProperty(item, styleContextStack, property, defaultValue) { + let value; + if (isValue(item[property])) { + // item defines this property + return item[property]; + } + if (!styleContextStack) { + return defaultValue; + } + styleContextStack.auto(item, () => { + value = styleContextStack.getProperty(property); + }); + return isValue(value) ? value : defaultValue; + } + + /** + * @param {object} source + * @param {object} destination + * @returns {object} + */ + static copyStyle(source, destination) { + if (source === void 0) { + source = {}; + } + if (destination === void 0) { + destination = {}; + } + // TODO: default style to source + + for (let key in source) { + if (key != 'text' && source.hasOwnProperty(key)) { + destination[key] = source[key]; + } + } + return destination; + } +} +/* harmony default export */ const src_StyleContextStack = (StyleContextStack); +;// ./src/TextBreaker.js + + + + +/** + * @param {string} text + * @param {boolean} noWrap + * @param {boolean} breakAll + * @returns {Array} + */ +const splitWords = function (text, noWrap, breakAll) { + if (breakAll === void 0) { + breakAll = false; + } + let words = []; + if (text === undefined || text === null) { + text = ''; + } else { + text = String(text); + } + if (noWrap) { + words.push({ + text: text + }); + return words; + } + if (breakAll) { + return text.split('').map(c => { + if (c.match(/^\n$|^\r$/)) { + // new line + return { + text: '', + lineEnd: true + }; + } + return { + text: c + }; + }); + } + if (text.length === 0) { + words.push({ + text: '' + }); + return words; + } + let breaker = new $557adaaeb0c7885f$exports(text); + let last = 0; + let bk; + while (bk = breaker.nextBreak()) { + let word = text.slice(last, bk.position); + if (bk.required || word.match(/\r?\n$|\r$/)) { + // new line + word = word.replace(/\r?\n$|\r$/, ''); + words.push({ + text: word, + lineEnd: true + }); + } else { + words.push({ + text: word + }); + } + last = bk.position; + } + return words; +}; + +/** + * @param {Array} words + * @param {boolean} noWrap + * @returns {?string} + */ +const getFirstWord = (words, noWrap) => { + let word = words[0]; + if (word === undefined) { + return null; + } + if (noWrap) { + // text was not wrapped, we need only first word + let tmpWords = splitWords(word.text, false); + if (tmpWords[0] === undefined) { + return null; + } + word = tmpWords[0]; + } + return word.text; +}; + +/** + * @param {Array} words + * @param {boolean} noWrap + * @returns {?string} + */ +const getLastWord = (words, noWrap) => { + let word = words[words.length - 1]; + if (word === undefined) { + return null; + } + if (word.lineEnd) { + return null; + } + if (noWrap) { + // text was not wrapped, we need only last word + let tmpWords = splitWords(word.text, false); + if (tmpWords[tmpWords.length - 1] === undefined) { + return null; + } + word = tmpWords[tmpWords.length - 1]; + } + return word.text; +}; +class TextBreaker { + /** + * @param {string|Array} texts + * @param {StyleContextStack} styleContextStack + * @returns {Array} + */ + getBreaks(texts, styleContextStack) { + let results = []; + if (!Array.isArray(texts)) { + texts = [texts]; + } + let lastWord = null; + for (let i = 0, l = texts.length; i < l; i++) { + let item = texts[i]; + let style = null; + let words; + let breakAll = src_StyleContextStack.getStyleProperty(item || {}, styleContextStack, 'wordBreak', 'normal') === 'break-all'; + let noWrap = src_StyleContextStack.getStyleProperty(item || {}, styleContextStack, 'noWrap', false); + if (isObject(item)) { + if (item._textRef && item._textRef._textNodeRef.text) { + item.text = item._textRef._textNodeRef.text; + } + words = splitWords(item.text, noWrap, breakAll); + style = src_StyleContextStack.copyStyle(item); + } else { + words = splitWords(item, noWrap, breakAll); + } + if (lastWord && words.length) { + let firstWord = getFirstWord(words, noWrap); + let wrapWords = splitWords(lastWord + firstWord, false); + if (wrapWords.length === 1) { + results[results.length - 1].noNewLine = true; + } + } + for (let i2 = 0, l2 = words.length; i2 < l2; i2++) { + let result = { + text: words[i2].text + }; + if (words[i2].lineEnd) { + result.lineEnd = true; + } + src_StyleContextStack.copyStyle(style, result); + results.push(result); + } + lastWord = null; + if (i + 1 < l) { + lastWord = getLastWord(words, noWrap); + } + } + return results; + } +} +/* harmony default export */ const src_TextBreaker = (TextBreaker); +;// ./src/TextInlines.js + + +const LEADING = /^(\s)+/g; +const TRAILING = /(\s)+$/g; + +/** + * @param {Array} array + * @returns {Array} + */ +const flattenTextArray = array => { + function flatten(array) { + return array.reduce((prev, cur) => { + let current = Array.isArray(cur.text) ? flatten(cur.text) : cur; + let more = [].concat(current).some(Array.isArray); + return prev.concat(more ? flatten(current) : current); + }, []); + } + if (!Array.isArray(array)) { + array = [array]; + } + + // TODO: Styling in nested text (issue: https://github.com/bpampuch/pdfmake/issues/1174) + + array = flatten(array); + return array; +}; + +/** + * Text measurement utility + */ +class TextInlines { + /** + * @param {object} pdfDocument object is instance of PDFDocument + */ + constructor(pdfDocument) { + this.pdfDocument = pdfDocument; + } + + /** + * Converts an array of strings (or inline-definition-objects) into a collection + * of inlines and calculated minWidth/maxWidth and their min/max widths + * + * @param {Array|object} textArray an array of inline-definition-objects (or strings) + * @param {StyleContextStack} styleContextStack current style stack + * @returns {object} collection of inlines, minWidth, maxWidth + */ + buildInlines(textArray, styleContextStack) { + const getTrimmedWidth = item => { + return Math.max(0, item.width - item.leadingCut - item.trailingCut); + }; + let minWidth = 0; + let maxWidth = 0; + let currentLineWidth; + let flattenedTextArray = flattenTextArray(textArray); + const textBreaker = new src_TextBreaker(); + let brokenText = textBreaker.getBreaks(flattenedTextArray, styleContextStack); + let measuredText = this.measure(brokenText, styleContextStack); + measuredText.forEach(inline => { + minWidth = Math.max(minWidth, getTrimmedWidth(inline)); + if (!currentLineWidth) { + currentLineWidth = { + width: 0, + leadingCut: inline.leadingCut, + trailingCut: 0 + }; + } + currentLineWidth.width += inline.width; + currentLineWidth.trailingCut = inline.trailingCut; + maxWidth = Math.max(maxWidth, getTrimmedWidth(currentLineWidth)); + if (inline.lineEnd) { + currentLineWidth = null; + } + }); + if (src_StyleContextStack.getStyleProperty({}, styleContextStack, 'noWrap', false)) { + minWidth = maxWidth; + } + return { + items: measuredText, + minWidth: minWidth, + maxWidth: maxWidth + }; + } + measure(array, styleContextStack) { + if (array.length) { + let leadingIndent = src_StyleContextStack.getStyleProperty(array[0], styleContextStack, 'leadingIndent', 0); + if (leadingIndent) { + array[0].leadingCut = -leadingIndent; + array[0].leadingIndent = leadingIndent; + } + } + array.forEach(item => { + let font = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'font', 'Roboto'); + let bold = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'bold', false); + let italics = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'italics', false); + item.font = this.pdfDocument.provideFont(font, bold, italics); + item.alignment = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'alignment', 'left'); + item.fontSize = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'fontSize', 12); + item.fontFeatures = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'fontFeatures', null); + item.characterSpacing = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'characterSpacing', 0); + item.color = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'color', 'black'); + item.decoration = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'decoration', null); + item.decorationColor = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'decorationColor', null); + item.decorationStyle = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'decorationStyle', null); + item.decorationThickness = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'decorationThickness', null); + item.background = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'background', null); + item.link = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'link', null); + item.linkToPage = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'linkToPage', null); + item.linkToDestination = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'linkToDestination', null); + item.noWrap = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'noWrap', null); + item.opacity = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'opacity', 1); + item.sup = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'sup', false); + item.sub = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'sub', false); + if (item.sup || item.sub) { + // font size reduction taken from here: https://en.wikipedia.org/wiki/Subscript_and_superscript#Desktop_publishing + item.fontSize *= 0.58; + } + let lineHeight = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'lineHeight', 1); + item.width = this.widthOfText(item.text, item); + item.height = item.font.lineHeight(item.fontSize) * lineHeight; + if (!item.leadingCut) { + item.leadingCut = 0; + } + let preserveLeadingSpaces = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'preserveLeadingSpaces', false); + if (!preserveLeadingSpaces) { + let leadingSpaces = item.text.match(LEADING); + if (leadingSpaces) { + item.leadingCut += this.widthOfText(leadingSpaces[0], item); + } + } + item.trailingCut = 0; + let preserveTrailingSpaces = src_StyleContextStack.getStyleProperty(item, styleContextStack, 'preserveTrailingSpaces', false); + if (!preserveTrailingSpaces) { + let trailingSpaces = item.text.match(TRAILING); + if (trailingSpaces) { + item.trailingCut = this.widthOfText(trailingSpaces[0], item); + } + } + }, this); + return array; + } + + /** + * Width of text + * + * @param {string} text + * @param {object} inline + * @returns {number} + */ + widthOfText(text, inline) { + return inline.font.widthOfString(text, inline.fontSize, inline.fontFeatures) + (inline.characterSpacing || 0) * (text.length - 1); + } + + /** + * Returns size of the specified string (without breaking it) using the current style + * + * @param {string} text text to be measured + * @param {object} styleContextStack current style stack + * @returns {object} size of the specified string + */ + sizeOfText(text, styleContextStack) { + //TODO: refactor - extract from measure + let fontName = src_StyleContextStack.getStyleProperty({}, styleContextStack, 'font', 'Roboto'); + let fontSize = src_StyleContextStack.getStyleProperty({}, styleContextStack, 'fontSize', 12); + let fontFeatures = src_StyleContextStack.getStyleProperty({}, styleContextStack, 'fontFeatures', null); + let bold = src_StyleContextStack.getStyleProperty({}, styleContextStack, 'bold', false); + let italics = src_StyleContextStack.getStyleProperty({}, styleContextStack, 'italics', false); + let lineHeight = src_StyleContextStack.getStyleProperty({}, styleContextStack, 'lineHeight', 1); + let characterSpacing = src_StyleContextStack.getStyleProperty({}, styleContextStack, 'characterSpacing', 0); + let font = this.pdfDocument.provideFont(fontName, bold, italics); + return { + width: this.widthOfText(text, { + font: font, + fontSize: fontSize, + characterSpacing: characterSpacing, + fontFeatures: fontFeatures + }), + height: font.lineHeight(fontSize) * lineHeight, + fontSize: fontSize, + lineHeight: lineHeight, + ascender: font.ascender / 1000 * fontSize, + descender: font.descender / 1000 * fontSize + }; + } + + /** + * Returns size of the specified rotated string (without breaking it) using the current style + * + * @param {string} text text to be measured + * @param {number} angle + * @param {object} styleContextStack current style stack + * @returns {object} size of the specified string + */ + sizeOfRotatedText(text, angle, styleContextStack) { + let angleRad = angle * Math.PI / -180; + let size = this.sizeOfText(text, styleContextStack); + return { + width: Math.abs(size.height * Math.sin(angleRad)) + Math.abs(size.width * Math.cos(angleRad)), + height: Math.abs(size.width * Math.sin(angleRad)) + Math.abs(size.height * Math.cos(angleRad)) + }; + } +} +/* harmony default export */ const src_TextInlines = (TextInlines); +;// ./src/columnCalculator.js + +function buildColumnWidths(columns, availableWidth, offsetTotal, tableNode) { + if (offsetTotal === void 0) { + offsetTotal = 0; + } + let autoColumns = []; + let autoMin = 0; + let autoMax = 0; + let starColumns = []; + let starMaxMin = 0; + let starMaxMax = 0; + let fixedColumns = []; + let initial_availableWidth = availableWidth; + columns.forEach(column => { + if (isAutoColumn(column)) { + autoColumns.push(column); + autoMin += column._minWidth; + autoMax += column._maxWidth; + } else if (isStarColumn(column)) { + starColumns.push(column); + starMaxMin = Math.max(starMaxMin, column._minWidth); + starMaxMax = Math.max(starMaxMax, column._maxWidth); + } else { + fixedColumns.push(column); + } + }); + fixedColumns.forEach((col, colIndex) => { + // width specified as % + if (isString(col.width) && /\d+%/.test(col.width)) { + // In tables we have to take into consideration the reserved width for paddings and borders + let reservedWidth = 0; + if (tableNode) { + const paddingLeft = tableNode._layout.paddingLeft(colIndex, tableNode); + const paddingRight = tableNode._layout.paddingRight(colIndex, tableNode); + const borderLeft = tableNode._layout.vLineWidth(colIndex, tableNode); + const borderRight = tableNode._layout.vLineWidth(colIndex + 1, tableNode); + if (colIndex === 0) { + // first column assumes whole borderLeft and half of border right + reservedWidth = paddingLeft + paddingRight + borderLeft + borderRight / 2; + } else if (colIndex === fixedColumns.length - 1) { + // last column assumes whole borderRight and half of border left + reservedWidth = paddingLeft + paddingRight + borderLeft / 2 + borderRight; + } else { + // Columns in the middle assume half of each border + reservedWidth = paddingLeft + paddingRight + borderLeft / 2 + borderRight / 2; + } + } + const totalAvailableWidth = initial_availableWidth + offsetTotal; + col.width = parseFloat(col.width) * totalAvailableWidth / 100 - reservedWidth; + } + if (col.width < col._minWidth && col.elasticWidth) { + col._calcWidth = col._minWidth; + } else { + col._calcWidth = col.width; + } + availableWidth -= col._calcWidth; + }); + + // http://www.freesoft.org/CIE/RFC/1942/18.htm + // http://www.w3.org/TR/CSS2/tables.html#width-layout + // http://dev.w3.org/csswg/css3-tables-algorithms/Overview.src.htm + let minW = autoMin + starMaxMin * starColumns.length; + let maxW = autoMax + starMaxMax * starColumns.length; + if (minW >= availableWidth) { + // case 1 - there's no way to fit all columns within available width + // that's actually pretty bad situation with PDF as we have no horizontal scroll + // no easy workaround (unless we decide, in the future, to split single words) + // currently we simply use minWidths for all columns + autoColumns.forEach(col => { + col._calcWidth = col._minWidth; + }); + starColumns.forEach(col => { + col._calcWidth = starMaxMin; // starMaxMin already contains padding + }); + } else { + if (maxW < availableWidth) { + // case 2 - we can fit rest of the table within available space + autoColumns.forEach(col => { + col._calcWidth = col._maxWidth; + availableWidth -= col._calcWidth; + }); + } else { + // maxW is too large, but minW fits within available width + let W = availableWidth - minW; + let D = maxW - minW; + autoColumns.forEach(col => { + let d = col._maxWidth - col._minWidth; + col._calcWidth = col._minWidth + d * W / D; + availableWidth -= col._calcWidth; + }); + } + if (starColumns.length > 0) { + let starSize = availableWidth / starColumns.length; + starColumns.forEach(col => { + col._calcWidth = starSize; + }); + } + } +} +function isAutoColumn(column) { + return column.width === 'auto'; +} +function isStarColumn(column) { + return column.width === null || column.width === undefined || column.width === '*' || column.width === 'star'; +} + +//TODO: refactor and reuse in measureTable +function measureMinMax(columns) { + let result = { + min: 0, + max: 0 + }; + let maxStar = { + min: 0, + max: 0 + }; + let starCount = 0; + for (let i = 0, l = columns.length; i < l; i++) { + let c = columns[i]; + if (isStarColumn(c)) { + maxStar.min = Math.max(maxStar.min, c._minWidth); + maxStar.max = Math.max(maxStar.max, c._maxWidth); + starCount++; + } else if (isAutoColumn(c)) { + result.min += c._minWidth; + result.max += c._maxWidth; + } else { + result.min += c.width !== undefined && c.width || c._minWidth; + result.max += c.width !== undefined && c.width || c._maxWidth; + } + } + if (starCount) { + result.min += starCount * maxStar.min; + result.max += starCount * maxStar.max; + } + return result; +} + +/** + * Calculates column widths + */ +/* harmony default export */ const columnCalculator = ({ + buildColumnWidths: buildColumnWidths, + measureMinMax: measureMinMax, + isAutoColumn: isAutoColumn, + isStarColumn: isStarColumn +}); +;// ./src/tableLayouts.js +/*eslint no-unused-vars: ["error", {"args": "none"}]*/ + + +const tableLayouts = { + noBorders: { + hLineWidth(i) { + return 0; + }, + vLineWidth(i) { + return 0; + }, + paddingLeft(i) { + return i && 4 || 0; + }, + paddingRight(i, node) { + return i < node.table.widths.length - 1 ? 4 : 0; + } + }, + headerLineOnly: { + hLineWidth(i, node) { + if (i === 0 || i === node.table.body.length) { + return 0; + } + return i === node.table.headerRows ? 2 : 0; + }, + vLineWidth(i) { + return 0; + }, + paddingLeft(i) { + return i === 0 ? 0 : 8; + }, + paddingRight(i, node) { + return i === node.table.widths.length - 1 ? 0 : 8; + } + }, + lightHorizontalLines: { + hLineWidth(i, node) { + if (i === 0 || i === node.table.body.length) { + return 0; + } + return i === node.table.headerRows ? 2 : 1; + }, + vLineWidth(i) { + return 0; + }, + hLineColor(i) { + return i === 1 ? 'black' : '#aaa'; + }, + paddingLeft(i) { + return i === 0 ? 0 : 8; + }, + paddingRight(i, node) { + return i === node.table.widths.length - 1 ? 0 : 8; + } + } +}; +const defaultTableLayout = { + hLineWidth(i, node) { + return 1; + }, + vLineWidth(i, node) { + return 1; + }, + hLineColor(i, node) { + return 'black'; + }, + vLineColor(i, node) { + return 'black'; + }, + hLineStyle(i, node) { + return null; + }, + vLineStyle(i, node) { + return null; + }, + paddingLeft(i, node) { + return 4; + }, + paddingRight(i, node) { + return 4; + }, + paddingTop(i, node) { + return 2; + }, + paddingBottom(i, node) { + return 2; + }, + fillColor(i, node) { + return null; + }, + fillOpacity(i, node) { + return 1; + }, + defaultBorder: true +}; +;// ./src/helpers/tools.js +function pack() { + let result = {}; + for (let i = 0, l = arguments.length; i < l; i++) { + let obj = i < 0 || arguments.length <= i ? undefined : arguments[i]; + if (obj) { + for (let key in obj) { + if (obj.hasOwnProperty(key)) { + result[key] = obj[key]; + } + } + } + } + return result; +} +function offsetVector(vector, x, y) { + switch (vector.type) { + case 'ellipse': + case 'rect': + vector.x += x; + vector.y += y; + break; + case 'line': + vector.x1 += x; + vector.x2 += x; + vector.y1 += y; + vector.y2 += y; + break; + case 'polyline': + for (let i = 0, l = vector.points.length; i < l; i++) { + vector.points[i].x += x; + vector.points[i].y += y; + } + break; + } +} +function convertToDynamicContent(staticContent) { + return () => + // copy to new object + JSON.parse(JSON.stringify(staticContent)); +} +;// ./src/qrEnc.js +/*eslint no-unused-vars: ["error", {"args": "none"}]*/ +/*eslint no-redeclare: "off"*/ +/*eslint no-throw-literal: "off"*/ + + + +/* qr.js -- QR code generator in Javascript (revision 2011-01-19) + * Written by Kang Seonghoon . + * + * This source code is in the public domain; if your jurisdiction does not + * recognize the public domain the terms of Creative Commons CC0 license + * apply. In the other words, you can always do what you want. + */ + +// per-version information (cf. JIS X 0510:2004 pp. 30--36, 71) +// +// [0]: the degree of generator polynomial by ECC levels +// [1]: # of code blocks by ECC levels +// [2]: left-top positions of alignment patterns +// +// the number in this table (in particular, [0]) does not exactly match with +// the numbers in the specficiation. see augumenteccs below for the reason. +var VERSIONS = [null, [[10, 7, 17, 13], [1, 1, 1, 1], []], [[16, 10, 28, 22], [1, 1, 1, 1], [4, 16]], [[26, 15, 22, 18], [1, 1, 2, 2], [4, 20]], [[18, 20, 16, 26], [2, 1, 4, 2], [4, 24]], [[24, 26, 22, 18], [2, 1, 4, 4], [4, 28]], [[16, 18, 28, 24], [4, 2, 4, 4], [4, 32]], [[18, 20, 26, 18], [4, 2, 5, 6], [4, 20, 36]], [[22, 24, 26, 22], [4, 2, 6, 6], [4, 22, 40]], [[22, 30, 24, 20], [5, 2, 8, 8], [4, 24, 44]], [[26, 18, 28, 24], [5, 4, 8, 8], [4, 26, 48]], [[30, 20, 24, 28], [5, 4, 11, 8], [4, 28, 52]], [[22, 24, 28, 26], [8, 4, 11, 10], [4, 30, 56]], [[22, 26, 22, 24], [9, 4, 16, 12], [4, 32, 60]], [[24, 30, 24, 20], [9, 4, 16, 16], [4, 24, 44, 64]], [[24, 22, 24, 30], [10, 6, 18, 12], [4, 24, 46, 68]], [[28, 24, 30, 24], [10, 6, 16, 17], [4, 24, 48, 72]], [[28, 28, 28, 28], [11, 6, 19, 16], [4, 28, 52, 76]], [[26, 30, 28, 28], [13, 6, 21, 18], [4, 28, 54, 80]], [[26, 28, 26, 26], [14, 7, 25, 21], [4, 28, 56, 84]], [[26, 28, 28, 30], [16, 8, 25, 20], [4, 32, 60, 88]], [[26, 28, 30, 28], [17, 8, 25, 23], [4, 26, 48, 70, 92]], [[28, 28, 24, 30], [17, 9, 34, 23], [4, 24, 48, 72, 96]], [[28, 30, 30, 30], [18, 9, 30, 25], [4, 28, 52, 76, 100]], [[28, 30, 30, 30], [20, 10, 32, 27], [4, 26, 52, 78, 104]], [[28, 26, 30, 30], [21, 12, 35, 29], [4, 30, 56, 82, 108]], [[28, 28, 30, 28], [23, 12, 37, 34], [4, 28, 56, 84, 112]], [[28, 30, 30, 30], [25, 12, 40, 34], [4, 32, 60, 88, 116]], [[28, 30, 30, 30], [26, 13, 42, 35], [4, 24, 48, 72, 96, 120]], [[28, 30, 30, 30], [28, 14, 45, 38], [4, 28, 52, 76, 100, 124]], [[28, 30, 30, 30], [29, 15, 48, 40], [4, 24, 50, 76, 102, 128]], [[28, 30, 30, 30], [31, 16, 51, 43], [4, 28, 54, 80, 106, 132]], [[28, 30, 30, 30], [33, 17, 54, 45], [4, 32, 58, 84, 110, 136]], [[28, 30, 30, 30], [35, 18, 57, 48], [4, 28, 56, 84, 112, 140]], [[28, 30, 30, 30], [37, 19, 60, 51], [4, 32, 60, 88, 116, 144]], [[28, 30, 30, 30], [38, 19, 63, 53], [4, 28, 52, 76, 100, 124, 148]], [[28, 30, 30, 30], [40, 20, 66, 56], [4, 22, 48, 74, 100, 126, 152]], [[28, 30, 30, 30], [43, 21, 70, 59], [4, 26, 52, 78, 104, 130, 156]], [[28, 30, 30, 30], [45, 22, 74, 62], [4, 30, 56, 82, 108, 134, 160]], [[28, 30, 30, 30], [47, 24, 77, 65], [4, 24, 52, 80, 108, 136, 164]], [[28, 30, 30, 30], [49, 25, 81, 68], [4, 28, 56, 84, 112, 140, 168]]]; + +// mode constants (cf. Table 2 in JIS X 0510:2004 p. 16) +var MODE_TERMINATOR = 0; +var MODE_NUMERIC = 1, + MODE_ALPHANUMERIC = 2, + MODE_OCTET = 4, + MODE_KANJI = 8; + +// validation regexps +var NUMERIC_REGEXP = /^\d*$/; +var ALPHANUMERIC_REGEXP = /^[A-Za-z0-9 $%*+\-./:]*$/; +var ALPHANUMERIC_OUT_REGEXP = /^[A-Z0-9 $%*+\-./:]*$/; + +// ECC levels (cf. Table 22 in JIS X 0510:2004 p. 45) +var ECCLEVEL_L = 1, + ECCLEVEL_M = 0, + ECCLEVEL_Q = 3, + ECCLEVEL_H = 2; + +// GF(2^8)-to-integer mapping with a reducing polynomial x^8+x^4+x^3+x^2+1 +// invariant: GF256_MAP[GF256_INVMAP[i]] == i for all i in [1,256) +var GF256_MAP = [], + GF256_INVMAP = [-1]; +for (var i = 0, v = 1; i < 255; ++i) { + GF256_MAP.push(v); + GF256_INVMAP[v] = i; + v = v * 2 ^ (v >= 128 ? 0x11d : 0); +} + +// generator polynomials up to degree 30 +// (should match with polynomials in JIS X 0510:2004 Appendix A) +// +// generator polynomial of degree K is product of (x-\alpha^0), (x-\alpha^1), +// ..., (x-\alpha^(K-1)). by convention, we omit the K-th coefficient (always 1) +// from the result; also other coefficients are written in terms of the exponent +// to \alpha to avoid the redundant calculation. (see also calculateecc below.) +var GF256_GENPOLY = [[]]; +for (var i = 0; i < 30; ++i) { + var prevpoly = GF256_GENPOLY[i], + poly = []; + for (var j = 0; j <= i; ++j) { + var a = j < i ? GF256_MAP[prevpoly[j]] : 0; + var b = GF256_MAP[(i + (prevpoly[j - 1] || 0)) % 255]; + poly.push(GF256_INVMAP[a ^ b]); + } + GF256_GENPOLY.push(poly); +} + +// alphanumeric character mapping (cf. Table 5 in JIS X 0510:2004 p. 19) +var ALPHANUMERIC_MAP = {}; +for (var i = 0; i < 45; ++i) { + ALPHANUMERIC_MAP['0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:'.charAt(i)] = i; +} + +// mask functions in terms of row # and column # +// (cf. Table 20 in JIS X 0510:2004 p. 42) +/*jshint unused: false */ +var MASKFUNCS = [function (i, j) { + return (i + j) % 2 === 0; +}, function (i, j) { + return i % 2 === 0; +}, function (i, j) { + return j % 3 === 0; +}, function (i, j) { + return (i + j) % 3 === 0; +}, function (i, j) { + return ((i / 2 | 0) + (j / 3 | 0)) % 2 === 0; +}, function (i, j) { + return i * j % 2 + i * j % 3 === 0; +}, function (i, j) { + return (i * j % 2 + i * j % 3) % 2 === 0; +}, function (i, j) { + return ((i + j) % 2 + i * j % 3) % 2 === 0; +}]; + +// returns true when the version information has to be embedded. +var needsverinfo = function (ver) { + return ver > 6; +}; + +// returns the size of entire QR code for given version. +var getsizebyver = function (ver) { + return 4 * ver + 17; +}; + +// returns the number of bits available for code words in this version. +var nfullbits = function (ver) { + /* + * |<--------------- n --------------->| + * | |<----- n-17 ---->| | + * +-------+ ///+-------+ ---- + * | | ///| | ^ + * | 9x9 | @@@@@ ///| 9x8 | | + * | | # # # @5x5@ # # # | | | + * +-------+ @@@@@ +-------+ | + * # ---| + * ^ | + * # | + * @@@@@ @@@@@ @@@@@ | n + * @5x5@ @5x5@ @5x5@ n-17 + * @@@@@ @@@@@ @@@@@ | | + * # | | + * ////// v | + * //////# ---| + * +-------+ @@@@@ @@@@@ | + * | | @5x5@ @5x5@ | + * | 8x9 | @@@@@ @@@@@ | + * | | v + * +-------+ ---- + * + * when the entire code has n^2 modules and there are m^2-3 alignment + * patterns, we have: + * - 225 (= 9x9 + 9x8 + 8x9) modules for finder patterns and + * format information; + * - 2n-34 (= 2(n-17)) modules for timing patterns; + * - 36 (= 3x6 + 6x3) modules for version information, if any; + * - 25m^2-75 (= (m^2-3)(5x5)) modules for alignment patterns + * if any, but 10m-20 (= 2(m-2)x5) of them overlaps with + * timing patterns. + */ + var v = VERSIONS[ver]; + var nbits = 16 * ver * ver + 128 * ver + 64; // finder, timing and format info. + if (needsverinfo(ver)) nbits -= 36; // version information + if (v[2].length) { + // alignment patterns + nbits -= 25 * v[2].length * v[2].length - 10 * v[2].length - 55; + } + return nbits; +}; + +// returns the number of bits available for data portions (i.e. excludes ECC +// bits but includes mode and length bits) in this version and ECC level. +var ndatabits = function (ver, ecclevel) { + var nbits = nfullbits(ver) & ~7; // no sub-octet code words + var v = VERSIONS[ver]; + nbits -= 8 * v[0][ecclevel] * v[1][ecclevel]; // ecc bits + return nbits; +}; + +// returns the number of bits required for the length of data. +// (cf. Table 3 in JIS X 0510:2004 p. 16) +var ndatalenbits = function (ver, mode) { + switch (mode) { + case MODE_NUMERIC: + return ver < 10 ? 10 : ver < 27 ? 12 : 14; + case MODE_ALPHANUMERIC: + return ver < 10 ? 9 : ver < 27 ? 11 : 13; + case MODE_OCTET: + return ver < 10 ? 8 : 16; + case MODE_KANJI: + return ver < 10 ? 8 : ver < 27 ? 10 : 12; + } +}; + +// returns the maximum length of data possible in given configuration. +var getmaxdatalen = function (ver, mode, ecclevel) { + var nbits = ndatabits(ver, ecclevel) - 4 - ndatalenbits(ver, mode); // 4 for mode bits + switch (mode) { + case MODE_NUMERIC: + return (nbits / 10 | 0) * 3 + (nbits % 10 < 4 ? 0 : nbits % 10 < 7 ? 1 : 2); + case MODE_ALPHANUMERIC: + return (nbits / 11 | 0) * 2 + (nbits % 11 < 6 ? 0 : 1); + case MODE_OCTET: + return nbits / 8 | 0; + case MODE_KANJI: + return nbits / 13 | 0; + } +}; + +// checks if the given data can be encoded in given mode, and returns +// the converted data for the further processing if possible. otherwise +// returns null. +// +// this function does not check the length of data; it is a duty of +// encode function below (as it depends on the version and ECC level too). +var validatedata = function (mode, data) { + switch (mode) { + case MODE_NUMERIC: + if (!data.match(NUMERIC_REGEXP)) return null; + return data; + case MODE_ALPHANUMERIC: + if (!data.match(ALPHANUMERIC_REGEXP)) return null; + return data.toUpperCase(); + case MODE_OCTET: + if (typeof data === 'string') { + // encode as utf-8 string + var newdata = []; + for (var i = 0; i < data.length; ++i) { + var ch = data.charCodeAt(i); + if (ch < 0x80) { + newdata.push(ch); + } else if (ch < 0x800) { + newdata.push(0xc0 | ch >> 6, 0x80 | ch & 0x3f); + } else if (ch < 0x10000) { + newdata.push(0xe0 | ch >> 12, 0x80 | ch >> 6 & 0x3f, 0x80 | ch & 0x3f); + } else { + newdata.push(0xf0 | ch >> 18, 0x80 | ch >> 12 & 0x3f, 0x80 | ch >> 6 & 0x3f, 0x80 | ch & 0x3f); + } + } + return newdata; + } else { + return data; + } + } +}; + +// returns the code words (sans ECC bits) for given data and configurations. +// requires data to be preprocessed by validatedata. no length check is +// performed, and everything has to be checked before calling this function. +var encode = function (ver, mode, data, maxbuflen) { + var buf = []; + var bits = 0, + remaining = 8; + var datalen = data.length; + + // this function is intentionally no-op when n=0. + var pack = function (x, n) { + if (n >= remaining) { + buf.push(bits | x >> (n -= remaining)); + while (n >= 8) buf.push(x >> (n -= 8) & 255); + bits = 0; + remaining = 8; + } + if (n > 0) bits |= (x & (1 << n) - 1) << (remaining -= n); + }; + var nlenbits = ndatalenbits(ver, mode); + pack(mode, 4); + pack(datalen, nlenbits); + switch (mode) { + case MODE_NUMERIC: + for (var i = 2; i < datalen; i += 3) { + pack(parseInt(data.substring(i - 2, i + 1), 10), 10); + } + pack(parseInt(data.substring(i - 2), 10), [0, 4, 7][datalen % 3]); + break; + case MODE_ALPHANUMERIC: + for (var i = 1; i < datalen; i += 2) { + pack(ALPHANUMERIC_MAP[data.charAt(i - 1)] * 45 + ALPHANUMERIC_MAP[data.charAt(i)], 11); + } + if (datalen % 2 == 1) { + pack(ALPHANUMERIC_MAP[data.charAt(i - 1)], 6); + } + break; + case MODE_OCTET: + for (var i = 0; i < datalen; ++i) { + pack(data[i], 8); + } + break; + } + + // final bits. it is possible that adding terminator causes the buffer + // to overflow, but then the buffer truncated to the maximum size will + // be valid as the truncated terminator mode bits and padding is + // identical in appearance (cf. JIS X 0510:2004 sec 8.4.8). + pack(MODE_TERMINATOR, 4); + if (remaining < 8) buf.push(bits); + + // the padding to fill up the remaining space. we should not add any + // words when the overflow already occurred. + while (buf.length + 1 < maxbuflen) buf.push(0xec, 0x11); + if (buf.length < maxbuflen) buf.push(0xec); + return buf; +}; + +// calculates ECC code words for given code words and generator polynomial. +// +// this is quite similar to CRC calculation as both Reed-Solomon and CRC use +// the certain kind of cyclic codes, which is effectively the division of +// zero-augmented polynomial by the generator polynomial. the only difference +// is that Reed-Solomon uses GF(2^8), instead of CRC's GF(2), and Reed-Solomon +// uses the different generator polynomial than CRC's. +var calculateecc = function (poly, genpoly) { + var modulus = poly.slice(0); + var polylen = poly.length, + genpolylen = genpoly.length; + for (var i = 0; i < genpolylen; ++i) modulus.push(0); + for (var i = 0; i < polylen;) { + var quotient = GF256_INVMAP[modulus[i++]]; + if (quotient >= 0) { + for (var j = 0; j < genpolylen; ++j) { + modulus[i + j] ^= GF256_MAP[(quotient + genpoly[j]) % 255]; + } + } + } + return modulus.slice(polylen); +}; + +// augments ECC code words to given code words. the resulting words are +// ready to be encoded in the matrix. +// +// the much of actual augmenting procedure follows JIS X 0510:2004 sec 8.7. +// the code is simplified using the fact that the size of each code & ECC +// blocks is almost same; for example, when we have 4 blocks and 46 data words +// the number of code words in those blocks are 11, 11, 12, 12 respectively. +var augumenteccs = function (poly, nblocks, genpoly) { + var subsizes = []; + var subsize = poly.length / nblocks | 0, + subsize0 = 0; + var pivot = nblocks - poly.length % nblocks; + for (var i = 0; i < pivot; ++i) { + subsizes.push(subsize0); + subsize0 += subsize; + } + for (var i = pivot; i < nblocks; ++i) { + subsizes.push(subsize0); + subsize0 += subsize + 1; + } + subsizes.push(subsize0); + var eccs = []; + for (var i = 0; i < nblocks; ++i) { + eccs.push(calculateecc(poly.slice(subsizes[i], subsizes[i + 1]), genpoly)); + } + var result = []; + var nitemsperblock = poly.length / nblocks | 0; + for (var i = 0; i < nitemsperblock; ++i) { + for (var j = 0; j < nblocks; ++j) { + result.push(poly[subsizes[j] + i]); + } + } + for (var j = pivot; j < nblocks; ++j) { + result.push(poly[subsizes[j + 1] - 1]); + } + for (var i = 0; i < genpoly.length; ++i) { + for (var j = 0; j < nblocks; ++j) { + result.push(eccs[j][i]); + } + } + return result; +}; + +// augments BCH(p+q,q) code to the polynomial over GF(2), given the proper +// genpoly. the both input and output are in binary numbers, and unlike +// calculateecc genpoly should include the 1 bit for the highest degree. +// +// actual polynomials used for this procedure are as follows: +// - p=10, q=5, genpoly=x^10+x^8+x^5+x^4+x^2+x+1 (JIS X 0510:2004 Appendix C) +// - p=18, q=6, genpoly=x^12+x^11+x^10+x^9+x^8+x^5+x^2+1 (ibid. Appendix D) +var augumentbch = function (poly, p, genpoly, q) { + var modulus = poly << q; + for (var i = p - 1; i >= 0; --i) { + if (modulus >> q + i & 1) modulus ^= genpoly << i; + } + return poly << q | modulus; +}; + +// creates the base matrix for given version. it returns two matrices, one of +// them is the actual one and the another represents the "reserved" portion +// (e.g. finder and timing patterns) of the matrix. +// +// some entries in the matrix may be undefined, rather than 0 or 1. this is +// intentional (no initialization needed!), and putdata below will fill +// the remaining ones. +var makebasematrix = function (ver) { + var v = VERSIONS[ver], + n = getsizebyver(ver); + var matrix = [], + reserved = []; + for (var i = 0; i < n; ++i) { + matrix.push([]); + reserved.push([]); + } + var blit = function (y, x, h, w, bits) { + for (var i = 0; i < h; ++i) { + for (var j = 0; j < w; ++j) { + matrix[y + i][x + j] = bits[i] >> j & 1; + reserved[y + i][x + j] = 1; + } + } + }; + + // finder patterns and a part of timing patterns + // will also mark the format information area (not yet written) as reserved. + blit(0, 0, 9, 9, [0x7f, 0x41, 0x5d, 0x5d, 0x5d, 0x41, 0x17f, 0x00, 0x40]); + blit(n - 8, 0, 8, 9, [0x100, 0x7f, 0x41, 0x5d, 0x5d, 0x5d, 0x41, 0x7f]); + blit(0, n - 8, 9, 8, [0xfe, 0x82, 0xba, 0xba, 0xba, 0x82, 0xfe, 0x00, 0x00]); + + // the rest of timing patterns + for (var i = 9; i < n - 8; ++i) { + matrix[6][i] = matrix[i][6] = ~i & 1; + reserved[6][i] = reserved[i][6] = 1; + } + + // alignment patterns + var aligns = v[2], + m = aligns.length; + for (var i = 0; i < m; ++i) { + var minj = i === 0 || i === m - 1 ? 1 : 0, + maxj = i === 0 ? m - 1 : m; + for (var j = minj; j < maxj; ++j) { + blit(aligns[i], aligns[j], 5, 5, [0x1f, 0x11, 0x15, 0x11, 0x1f]); + } + } + + // version information + if (needsverinfo(ver)) { + var code = augumentbch(ver, 6, 0x1f25, 12); + var k = 0; + for (var i = 0; i < 6; ++i) { + for (var j = 0; j < 3; ++j) { + matrix[i][n - 11 + j] = matrix[n - 11 + j][i] = code >> k++ & 1; + reserved[i][n - 11 + j] = reserved[n - 11 + j][i] = 1; + } + } + } + return { + matrix: matrix, + reserved: reserved + }; +}; + +// fills the data portion (i.e. unmarked in reserved) of the matrix with given +// code words. the size of code words should be no more than available bits, +// and remaining bits are padded to 0 (cf. JIS X 0510:2004 sec 8.7.3). +var putdata = function (matrix, reserved, buf) { + var n = matrix.length; + var k = 0, + dir = -1; + for (var i = n - 1; i >= 0; i -= 2) { + if (i == 6) --i; // skip the entire timing pattern column + var jj = dir < 0 ? n - 1 : 0; + for (var j = 0; j < n; ++j) { + for (var ii = i; ii > i - 2; --ii) { + if (!reserved[jj][ii]) { + // may overflow, but (undefined >> x) + // is 0 so it will auto-pad to zero. + matrix[jj][ii] = buf[k >> 3] >> (~k & 7) & 1; + ++k; + } + } + jj += dir; + } + dir = -dir; + } + return matrix; +}; + +// XOR-masks the data portion of the matrix. repeating the call with the same +// arguments will revert the prior call (convenient in the matrix evaluation). +var maskdata = function (matrix, reserved, mask) { + var maskf = MASKFUNCS[mask]; + var n = matrix.length; + for (var i = 0; i < n; ++i) { + for (var j = 0; j < n; ++j) { + if (!reserved[i][j]) matrix[i][j] ^= maskf(i, j); + } + } + return matrix; +}; + +// puts the format information. +var putformatinfo = function (matrix, reserved, ecclevel, mask) { + var n = matrix.length; + var code = augumentbch(ecclevel << 3 | mask, 5, 0x537, 10) ^ 0x5412; + for (var i = 0; i < 15; ++i) { + var r = [0, 1, 2, 3, 4, 5, 7, 8, n - 7, n - 6, n - 5, n - 4, n - 3, n - 2, n - 1][i]; + var c = [n - 1, n - 2, n - 3, n - 4, n - 5, n - 6, n - 7, n - 8, 7, 5, 4, 3, 2, 1, 0][i]; + matrix[r][8] = matrix[8][c] = code >> i & 1; + // we don't have to mark those bits reserved; always done + // in makebasematrix above. + } + return matrix; +}; + +// evaluates the resulting matrix and returns the score (lower is better). +// (cf. JIS X 0510:2004 sec 8.8.2) +// +// the evaluation procedure tries to avoid the problematic patterns naturally +// occurring from the original matrix. for example, it penaltizes the patterns +// which just look like the finder pattern which will confuse the decoder. +// we choose the mask which results in the lowest score among 8 possible ones. +// +// note: zxing seems to use the same procedure and in many cases its choice +// agrees to ours, but sometimes it does not. practically it doesn't matter. +var evaluatematrix = function (matrix) { + // N1+(k-5) points for each consecutive row of k same-colored modules, + // where k >= 5. no overlapping row counts. + var PENALTY_CONSECUTIVE = 3; + // N2 points for each 2x2 block of same-colored modules. + // overlapping block does count. + var PENALTY_TWOBYTWO = 3; + // N3 points for each pattern with >4W:1B:1W:3B:1W:1B or + // 1B:1W:3B:1W:1B:>4W, or their multiples (e.g. highly unlikely, + // but 13W:3B:3W:9B:3W:3B counts). + var PENALTY_FINDERLIKE = 40; + // N4*k points for every (5*k)% deviation from 50% black density. + // i.e. k=1 for 55~60% and 40~45%, k=2 for 60~65% and 35~40%, etc. + var PENALTY_DENSITY = 10; + var evaluategroup = function (groups) { + // assumes [W,B,W,B,W,...,B,W] + var score = 0; + for (var i = 0; i < groups.length; ++i) { + if (groups[i] >= 5) score += PENALTY_CONSECUTIVE + (groups[i] - 5); + } + for (var i = 5; i < groups.length; i += 2) { + var p = groups[i]; + if (groups[i - 1] == p && groups[i - 2] == 3 * p && groups[i - 3] == p && groups[i - 4] == p && (groups[i - 5] >= 4 * p || groups[i + 1] >= 4 * p)) { + // this part differs from zxing... + score += PENALTY_FINDERLIKE; + } + } + return score; + }; + var n = matrix.length; + var score = 0, + nblacks = 0; + for (var i = 0; i < n; ++i) { + var row = matrix[i]; + var groups; + + // evaluate the current row + groups = [0]; // the first empty group of white + for (var j = 0; j < n;) { + var k; + for (k = 0; j < n && row[j]; ++k) ++j; + groups.push(k); + for (k = 0; j < n && !row[j]; ++k) ++j; + groups.push(k); + } + score += evaluategroup(groups); + + // evaluate the current column + groups = [0]; + for (var j = 0; j < n;) { + var k; + for (k = 0; j < n && matrix[j][i]; ++k) ++j; + groups.push(k); + for (k = 0; j < n && !matrix[j][i]; ++k) ++j; + groups.push(k); + } + score += evaluategroup(groups); + + // check the 2x2 box and calculate the density + var nextrow = matrix[i + 1] || []; + nblacks += row[0]; + for (var j = 1; j < n; ++j) { + var p = row[j]; + nblacks += p; + // at least comparison with next row should be strict... + if (row[j - 1] == p && nextrow[j] === p && nextrow[j - 1] === p) { + score += PENALTY_TWOBYTWO; + } + } + } + score += PENALTY_DENSITY * (Math.abs(nblacks / n / n - 0.5) / 0.05 | 0); + return score; +}; + +// returns the fully encoded QR code matrix which contains given data. +// it also chooses the best mask automatically when mask is -1. +var generate = function (data, ver, mode, ecclevel, mask) { + var v = VERSIONS[ver]; + var buf = encode(ver, mode, data, ndatabits(ver, ecclevel) >> 3); + buf = augumenteccs(buf, v[1][ecclevel], GF256_GENPOLY[v[0][ecclevel]]); + var result = makebasematrix(ver); + var matrix = result.matrix, + reserved = result.reserved; + putdata(matrix, reserved, buf); + if (mask < 0) { + // find the best mask + maskdata(matrix, reserved, 0); + putformatinfo(matrix, reserved, ecclevel, 0); + var bestmask = 0, + bestscore = evaluatematrix(matrix); + maskdata(matrix, reserved, 0); + for (mask = 1; mask < 8; ++mask) { + maskdata(matrix, reserved, mask); + putformatinfo(matrix, reserved, ecclevel, mask); + var score = evaluatematrix(matrix); + if (bestscore > score) { + bestscore = score; + bestmask = mask; + } + maskdata(matrix, reserved, mask); + } + mask = bestmask; + } + maskdata(matrix, reserved, mask); + putformatinfo(matrix, reserved, ecclevel, mask); + return matrix; +}; + +// the public interface is trivial; the options available are as follows: +// +// - version: an integer in [1,40]. when omitted (or -1) the smallest possible +// version is chosen. +// - mode: one of 'numeric', 'alphanumeric', 'octet'. when omitted the smallest +// possible mode is chosen. +// - eccLevel: one of 'L', 'M', 'Q', 'H'. defaults to 'L'. +// - mask: an integer in [0,7]. when omitted (or -1) the best mask is chosen. +// + +function generateFrame(data, options) { + var MODES = { + 'numeric': MODE_NUMERIC, + 'alphanumeric': MODE_ALPHANUMERIC, + 'octet': MODE_OCTET + }; + var ECCLEVELS = { + 'L': ECCLEVEL_L, + 'M': ECCLEVEL_M, + 'Q': ECCLEVEL_Q, + 'H': ECCLEVEL_H + }; + options = options || {}; + var ver = options.version || -1; + var ecclevel = ECCLEVELS[(options.eccLevel || 'L').toUpperCase()]; + var mode = options.mode ? MODES[options.mode.toLowerCase()] : -1; + var mask = 'mask' in options ? options.mask : -1; + if (mode < 0) { + if (typeof data === 'string') { + if (data.match(NUMERIC_REGEXP)) { + mode = MODE_NUMERIC; + } else if (data.match(ALPHANUMERIC_OUT_REGEXP)) { + // while encode supports case-insensitive encoding, we restrict the data to be uppercased when auto-selecting the mode. + mode = MODE_ALPHANUMERIC; + } else { + mode = MODE_OCTET; + } + } else { + mode = MODE_OCTET; + } + } else if (!(mode == MODE_NUMERIC || mode == MODE_ALPHANUMERIC || mode == MODE_OCTET)) { + throw 'invalid or unsupported mode'; + } + data = validatedata(mode, data); + if (data === null) throw 'invalid data format'; + if (ecclevel < 0 || ecclevel > 3) throw 'invalid ECC level'; + if (ver < 0) { + for (ver = 1; ver <= 40; ++ver) { + if (data.length <= getmaxdatalen(ver, mode, ecclevel)) break; + } + if (ver > 40) throw 'too large data for the Qr format'; + } else if (ver < 1 || ver > 40) { + throw 'invalid Qr version! should be between 1 and 40'; + } + if (mask != -1 && (mask < 0 || mask > 8)) throw 'invalid mask'; + //console.log('version:', ver, 'mode:', mode, 'ECC:', ecclevel, 'mask:', mask ) + return generate(data, ver, mode, ecclevel, mask); +} + +// options +// - modulesize: a number. this is a size of each modules in pixels, and +// defaults to 5px. +// - margin: a number. this is a size of margin in *modules*, and defaults to +// 4 (white modules). the specficiation mandates the margin no less than 4 +// modules, so it is better not to alter this value unless you know what +// you're doing. +function buildCanvas(data, options) { + var canvas = []; + var background = options.background || '#fff'; + var foreground = options.foreground || '#000'; + var padding = options.padding || 0; + //var margin = options.margin || 4; + var matrix = generateFrame(data, options); + var n = matrix.length; + var modSize = Math.floor(options.fit ? options.fit / n : 5); + var size = n * modSize + modSize * padding * 2; + var paddingXY = modSize * padding; + canvas.push({ + type: 'rect', + x: 0, + y: 0, + w: size, + h: size, + lineWidth: 0, + color: background + }); + for (var i = 0; i < n; ++i) { + for (var j = 0; j < n; ++j) { + if (matrix[i][j]) { + canvas.push({ + type: 'rect', + x: modSize * j + paddingXY, + y: modSize * i + paddingXY, + w: modSize, + h: modSize, + lineWidth: 0, + color: foreground + }); + } + } + } + return { + canvas: canvas, + size: size + }; +} +function measure(node) { + var cd = buildCanvas(node.qr, node); + node._canvas = cd.canvas; + node._width = node._height = node._minWidth = node._maxWidth = node._minHeight = node._maxHeight = cd.size; + return node; +} +/* harmony default export */ const qrEnc = ({ + measure: measure +}); +;// ./src/DocMeasure.js + + + + + + + + +class DocMeasure { + constructor(pdfDocument, styleDictionary, defaultStyle, svgMeasure, tableLayouts) { + this.pdfDocument = pdfDocument; + this.textInlines = new src_TextInlines(pdfDocument); + this.styleStack = new src_StyleContextStack(styleDictionary, defaultStyle); + this.svgMeasure = svgMeasure; + this.tableLayouts = tableLayouts; + this.autoImageIndex = 1; + } + + /** + * Measures all nodes and sets min/max-width properties required for the second + * layout-pass. + * + * @param {object} docStructure document-definition-object + * @returns {object} document-measurement-object + */ + measureDocument(docStructure) { + return this.measureNode(docStructure); + } + measureBlock(node) { + return this.measureNode(node); + } + measureNode(node) { + return this.styleStack.auto(node, () => { + // TODO: refactor + rethink whether this is the proper way to handle margins + node._margin = getNodeMargin(node, this.styleStack); + if (node.section) { + return extendMargins(this.measureSection(node)); + } else if (node.columns) { + return extendMargins(this.measureColumns(node)); + } else if (node.stack) { + return extendMargins(this.measureVerticalContainer(node)); + } else if (node.ul) { + return extendMargins(this.measureUnorderedList(node)); + } else if (node.ol) { + return extendMargins(this.measureOrderedList(node)); + } else if (node.table) { + return extendMargins(this.measureTable(node)); + } else if (node.text !== undefined) { + return extendMargins(this.measureLeaf(node)); + } else if (node.toc) { + return extendMargins(this.measureToc(node)); + } else if (node.image) { + return extendMargins(this.measureImage(node)); + } else if (node.svg) { + return extendMargins(this.measureSVG(node)); + } else if (node.canvas) { + return extendMargins(this.measureCanvas(node)); + } else if (node.qr) { + return extendMargins(this.measureQr(node)); + } else if (node.attachment) { + return extendMargins(this.measureAttachment(node)); + } else { + throw new Error(`Unrecognized document structure: ${stringifyNode(node)}`); + } + }); + function extendMargins(node) { + let margin = node._margin; + if (margin) { + node._minWidth += margin[0] + margin[2]; + node._maxWidth += margin[0] + margin[2]; + } + return node; + } + } + measureImageWithDimensions(node, dimensions) { + if (node.fit) { + let factor = dimensions.width / dimensions.height > node.fit[0] / node.fit[1] ? node.fit[0] / dimensions.width : node.fit[1] / dimensions.height; + node._width = node._minWidth = node._maxWidth = dimensions.width * factor; + node._height = dimensions.height * factor; + } else if (node.cover) { + node._width = node._minWidth = node._maxWidth = node.cover.width; + node._height = node._minHeight = node._maxHeight = node.cover.height; + } else { + let nodeWidth = isNumber(node.width) ? node.width : undefined; + let nodeHeight = isNumber(node.height) ? node.height : undefined; + let ratio = dimensions.width / dimensions.height; + node._width = node._minWidth = node._maxWidth = nodeWidth || (nodeHeight ? nodeHeight * ratio : dimensions.width); + node._height = nodeHeight || (nodeWidth ? nodeWidth / ratio : dimensions.height); + if (isNumber(node.maxWidth) && node.maxWidth < node._width) { + node._width = node._minWidth = node._maxWidth = node.maxWidth; + node._height = node._width * dimensions.height / dimensions.width; + } + if (isNumber(node.maxHeight) && node.maxHeight < node._height) { + node._height = node.maxHeight; + node._width = node._minWidth = node._maxWidth = node._height * dimensions.width / dimensions.height; + } + if (isNumber(node.minWidth) && node.minWidth > node._width) { + node._width = node._minWidth = node._maxWidth = node.minWidth; + node._height = node._width * dimensions.height / dimensions.width; + } + if (isNumber(node.minHeight) && node.minHeight > node._height) { + node._height = node.minHeight; + node._width = node._minWidth = node._maxWidth = node._height * dimensions.width / dimensions.height; + } + } + node._alignment = this.styleStack.getProperty('alignment'); + } + convertIfBase64Image(node) { + if (/^data:image\/(jpeg|jpg|png);base64,/.test(node.image)) { + // base64 image + let label = `$$pdfmake$$${this.autoImageIndex++}`; + this.pdfDocument.images[label] = node.image; + node.image = label; + } + } + measureImage(node) { + this.convertIfBase64Image(node); + let image = this.pdfDocument.provideImage(node.image); + let imageSize = { + width: image.width, + height: image.height + }; + + // If EXIF orientation calls for it, swap width and height + if (image.orientation > 4) { + imageSize = { + width: image.height, + height: image.width + }; + } + this.measureImageWithDimensions(node, imageSize); + return node; + } + measureSVG(node) { + let dimensions = this.svgMeasure.measureSVG(node.svg); + this.measureImageWithDimensions(node, dimensions); + node.font = this.styleStack.getProperty('font'); + + // SVG requires a defined width and height + if (!isNumber(node._width) && !isNumber(node._height)) { + throw new Error('SVG is missing defined width and height.'); + } else if (!isNumber(node._width)) { + throw new Error('SVG is missing defined width.'); + } else if (!isNumber(node._height)) { + throw new Error('SVG is missing defined height.'); + } + + // scale SVG based on final dimension + node.svg = this.svgMeasure.writeDimensions(node.svg, { + width: node._width, + height: node._height + }); + return node; + } + measureLeaf(node) { + if (node._textRef && node._textRef._textNodeRef.text) { + node.text = node._textRef._textNodeRef.text; + } + + // Make sure style properties of the node itself are considered when building inlines. + // We could also just pass [node] to buildInlines, but that fails for bullet points. + let styleStack = this.styleStack.clone(); + styleStack.push(node); + let data = this.textInlines.buildInlines(node.text, styleStack); + node._inlines = data.items; + node._minWidth = data.minWidth; + node._maxWidth = data.maxWidth; + return node; + } + measureToc(node) { + if (node.toc.title) { + node.toc.title = this.measureNode(node.toc.title); + } + if (node.toc._items.length > 0) { + let body = []; + let textStyle = node.toc.textStyle || {}; + let numberStyle = node.toc.numberStyle || textStyle; + let textMargin = node.toc.textMargin || [0, 0, 0, 0]; + if (node.toc.sortBy === 'title') { + node.toc._items.sort((a, b) => { + return a._textNodeRef.text.localeCompare(b._textNodeRef.text, node.toc.sortLocale); + }); + } + for (let i = 0, l = node.toc._items.length; i < l; i++) { + let item = node.toc._items[i]; + let lineStyle = item._textNodeRef.tocStyle || textStyle; + let lineMargin = item._textNodeRef.tocMargin || textMargin; + let lineNumberStyle = item._textNodeRef.tocNumberStyle || numberStyle; + let destination = getNodeId(item._nodeRef); + body.push([{ + text: item._textNodeRef.text, + linkToDestination: destination, + alignment: 'left', + style: lineStyle, + margin: lineMargin + }, { + text: '00000', + linkToDestination: destination, + alignment: 'right', + _tocItemRef: item._nodeRef, + style: lineNumberStyle, + margin: [0, lineMargin[1], 0, lineMargin[3]] + }]); + if (node.toc.outlines) { + item._textNodeRef.outline = item._textNodeRef.outline || true; + } + } + node.toc._table = { + table: { + dontBreakRows: true, + widths: ['*', 'auto'], + body: body + }, + layout: 'noBorders' + }; + node.toc._table = this.measureNode(node.toc._table); + } + return node; + } + measureVerticalContainer(node) { + let items = node.stack; + node._minWidth = 0; + node._maxWidth = 0; + for (let i = 0, l = items.length; i < l; i++) { + items[i] = this.measureNode(items[i]); + node._minWidth = Math.max(node._minWidth, items[i]._minWidth); + node._maxWidth = Math.max(node._maxWidth, items[i]._maxWidth); + } + return node; + } + gapSizeForList() { + return this.textInlines.sizeOfText('9. ', this.styleStack); + } + buildUnorderedMarker(item, styleStack, gapSize, type) { + function buildDisc(gapSize, color) { + // TODO: ascender-based calculations + let radius = gapSize.fontSize / 6; + return { + canvas: [{ + x: radius, + y: gapSize.height / gapSize.lineHeight + gapSize.descender - gapSize.fontSize / 3, + r1: radius, + r2: radius, + type: 'ellipse', + color: color + }] + }; + } + function buildSquare(gapSize, color) { + // TODO: ascender-based calculations + let size = gapSize.fontSize / 3; + return { + canvas: [{ + x: 0, + y: gapSize.height / gapSize.lineHeight + gapSize.descender - gapSize.fontSize / 3 - size / 2, + h: size, + w: size, + type: 'rect', + color: color + }] + }; + } + function buildCircle(gapSize, color) { + // TODO: ascender-based calculations + let radius = gapSize.fontSize / 6; + return { + canvas: [{ + x: radius, + y: gapSize.height / gapSize.lineHeight + gapSize.descender - gapSize.fontSize / 3, + r1: radius, + r2: radius, + type: 'ellipse', + lineColor: color + }] + }; + } + let marker; + let color = src_StyleContextStack.getStyleProperty(item, styleStack, 'markerColor', undefined) || styleStack.getProperty('color') || 'black'; + switch (type) { + case 'circle': + marker = buildCircle(gapSize, color); + break; + case 'square': + marker = buildSquare(gapSize, color); + break; + case 'none': + marker = {}; + break; + case 'disc': + default: + marker = buildDisc(gapSize, color); + break; + } + marker._minWidth = marker._maxWidth = gapSize.width; + marker._minHeight = marker._maxHeight = gapSize.height; + return marker; + } + buildOrderedMarker(item, counter, styleStack, type, separator) { + function prepareAlpha(counter) { + function toAlpha(num) { + return (num >= 26 ? toAlpha((num / 26 >> 0) - 1) : '') + 'abcdefghijklmnopqrstuvwxyz'[num % 26 >> 0]; + } + if (counter < 1) { + return counter.toString(); + } + return toAlpha(counter - 1); + } + function prepareRoman(counter) { + if (counter < 1 || counter > 4999) { + return counter.toString(); + } + let num = counter; + let lookup = { + M: 1000, + CM: 900, + D: 500, + CD: 400, + C: 100, + XC: 90, + L: 50, + XL: 40, + X: 10, + IX: 9, + V: 5, + IV: 4, + I: 1 + }; + let roman = ''; + for (let i in lookup) { + while (num >= lookup[i]) { + roman += i; + num -= lookup[i]; + } + } + return roman; + } + function prepareDecimal(counter) { + return counter.toString(); + } + let counterText; + switch (type) { + case 'none': + counterText = null; + break; + case 'upper-alpha': + counterText = prepareAlpha(counter).toUpperCase(); + break; + case 'lower-alpha': + counterText = prepareAlpha(counter); + break; + case 'upper-roman': + counterText = prepareRoman(counter); + break; + case 'lower-roman': + counterText = prepareRoman(counter).toLowerCase(); + break; + case 'decimal': + default: + counterText = prepareDecimal(counter); + break; + } + if (counterText === null) { + return {}; + } + if (separator) { + if (Array.isArray(separator)) { + if (separator[0]) { + counterText = separator[0] + counterText; + } + if (separator[1]) { + counterText += separator[1]; + } + counterText += ' '; + } else { + counterText += `${separator} `; + } + } + let markerColor = src_StyleContextStack.getStyleProperty(item, styleStack, 'markerColor', undefined) || styleStack.getProperty('color') || 'black'; + let textArray = { + text: counterText, + color: markerColor + }; + return { + _inlines: this.textInlines.buildInlines(textArray, styleStack).items + }; + } + measureUnorderedList(node) { + let style = this.styleStack.clone(); + let items = node.ul; + node.type = node.type || 'disc'; + node._gapSize = this.gapSizeForList(); + node._minWidth = 0; + node._maxWidth = 0; + for (let i = 0, l = items.length; i < l; i++) { + let item = items[i] = this.measureNode(items[i]); + if (!item.ol && !item.ul) { + item.listMarker = this.buildUnorderedMarker(item, style, node._gapSize, item.listType || node.type); + } + node._minWidth = Math.max(node._minWidth, items[i]._minWidth + node._gapSize.width); + node._maxWidth = Math.max(node._maxWidth, items[i]._maxWidth + node._gapSize.width); + } + return node; + } + measureOrderedList(node) { + let style = this.styleStack.clone(); + let items = node.ol; + node.type = node.type || 'decimal'; + node.separator = node.separator || '.'; + node.reversed = node.reversed || false; + if (!isNumber(node.start)) { + node.start = node.reversed ? items.length : 1; + } + node._gapSize = this.gapSizeForList(); + node._minWidth = 0; + node._maxWidth = 0; + let counter = node.start; + for (let i = 0, l = items.length; i < l; i++) { + let item = items[i] = this.measureNode(items[i]); + if (!item.ol && !item.ul) { + let counterValue = isNumber(item.counter) ? item.counter : counter; + item.listMarker = this.buildOrderedMarker(item, counterValue, style, item.listType || node.type, node.separator); + if (item.listMarker._inlines) { + node._gapSize.width = Math.max(node._gapSize.width, item.listMarker._inlines[0].width); + } + if (node.reversed) { + counter--; + } else { + counter++; + } + } + node._minWidth = Math.max(node._minWidth, items[i]._minWidth); + node._maxWidth = Math.max(node._maxWidth, items[i]._maxWidth); + } + node._minWidth += node._gapSize.width; + node._maxWidth += node._gapSize.width; + for (let i = 0, l = items.length; i < l; i++) { + let item = items[i]; + if (!item.ol && !item.ul) { + item.listMarker._minWidth = item.listMarker._maxWidth = node._gapSize.width; + } + } + return node; + } + measureSection(node) { + // TODO: properties + + node.section = this.measureNode(node.section); + return node; + } + measureColumns(node) { + let columns = node.columns; + node._gap = this.styleStack.getProperty('columnGap') || 0; + for (let i = 0, l = columns.length; i < l; i++) { + columns[i] = this.measureNode(columns[i]); + } + let measures = columnCalculator.measureMinMax(columns); + let numGaps = columns.length > 0 ? columns.length - 1 : 0; + node._minWidth = measures.min + node._gap * numGaps; + node._maxWidth = measures.max + node._gap * numGaps; + return node; + } + measureTable(node) { + extendTableWidths(node); + node._layout = getLayout(this.tableLayouts); + node._offsets = getOffsets(node._layout); + let colSpans = []; + let col; + let row; + let cols; + let rows; + for (col = 0, cols = node.table.body[0].length; col < cols; col++) { + let c = node.table.widths[col]; + c._minWidth = 0; + c._maxWidth = 0; + for (row = 0, rows = node.table.body.length; row < rows; row++) { + let rowData = node.table.body[row]; + let data = rowData[col]; + if (data === undefined) { + throw new Error(`Malformed table row, a cell is undefined.\nRow index: ${row}\nColumn index: ${col}\nRow data: ${stringifyNode(rowData)}`); + } + if (data === null) { + // transform to object + data = ''; + } + if (!data._span) { + data = rowData[col] = this.styleStack.auto(data, measureCb(this, data)); + if (data.colSpan && data.colSpan > 1) { + markSpans(rowData, col, data.colSpan); + colSpans.push({ + col: col, + span: data.colSpan, + minWidth: data._minWidth, + maxWidth: data._maxWidth + }); + } else { + c._minWidth = Math.max(c._minWidth, data._minWidth); + c._maxWidth = Math.max(c._maxWidth, data._maxWidth); + } + } + if (data.rowSpan && data.rowSpan > 1) { + markVSpans(node.table, row, col, data.rowSpan); + } + } + } + extendWidthsForColSpans(); + let measures = columnCalculator.measureMinMax(node.table.widths); + node._minWidth = measures.min + node._offsets.total; + node._maxWidth = measures.max + node._offsets.total; + return node; + function measureCb(_this, data) { + return () => { + if (isObject(data)) { + data.fillColor = _this.styleStack.getProperty('fillColor'); + data.fillOpacity = _this.styleStack.getProperty('fillOpacity'); + } + return _this.measureNode(data); + }; + } + function getLayout(tableLayouts) { + let layout = node.layout; + if (isString(layout)) { + layout = tableLayouts[layout]; + } + return pack(defaultTableLayout, layout); + } + function getOffsets(layout) { + let offsets = []; + let totalOffset = 0; + let prevRightPadding = 0; + for (let i = 0, l = node.table.widths.length; i < l; i++) { + let lOffset = prevRightPadding + layout.vLineWidth(i, node) + layout.paddingLeft(i, node); + offsets.push(lOffset); + totalOffset += lOffset; + prevRightPadding = layout.paddingRight(i, node); + } + totalOffset += prevRightPadding + layout.vLineWidth(node.table.widths.length, node); + return { + total: totalOffset, + offsets: offsets + }; + } + function extendWidthsForColSpans() { + let q; + let j; + for (let i = 0, l = colSpans.length; i < l; i++) { + let span = colSpans[i]; + let currentMinMax = getMinMax(span.col, span.span, node._offsets); + let minDifference = span.minWidth - currentMinMax.minWidth; + let maxDifference = span.maxWidth - currentMinMax.maxWidth; + if (minDifference > 0) { + q = minDifference / span.span; + for (j = 0; j < span.span; j++) { + node.table.widths[span.col + j]._minWidth += q; + } + } + if (maxDifference > 0) { + q = maxDifference / span.span; + for (j = 0; j < span.span; j++) { + node.table.widths[span.col + j]._maxWidth += q; + } + } + } + } + function getMinMax(col, span, offsets) { + let result = { + minWidth: 0, + maxWidth: 0 + }; + for (let i = 0; i < span; i++) { + result.minWidth += node.table.widths[col + i]._minWidth + (i ? offsets.offsets[col + i] : 0); + result.maxWidth += node.table.widths[col + i]._maxWidth + (i ? offsets.offsets[col + i] : 0); + } + return result; + } + function markSpans(rowData, col, span) { + for (let i = 1; i < span; i++) { + rowData[col + i] = { + _span: true, + _minWidth: 0, + _maxWidth: 0, + rowSpan: rowData[col].rowSpan + }; + } + } + function markVSpans(table, row, col, span) { + for (let i = 1; i < span; i++) { + table.body[row + i][col] = { + _span: true, + _minWidth: 0, + _maxWidth: 0, + fillColor: table.body[row][col].fillColor, + fillOpacity: table.body[row][col].fillOpacity + }; + } + } + function extendTableWidths(node) { + if (!node.table.widths) { + node.table.widths = 'auto'; + } + if (isString(node.table.widths)) { + node.table.widths = [node.table.widths]; + while (node.table.widths.length < node.table.body[0].length) { + node.table.widths.push(node.table.widths[node.table.widths.length - 1]); + } + } + for (let i = 0, l = node.table.widths.length; i < l; i++) { + let w = node.table.widths[i]; + if (isNumber(w) || isString(w)) { + node.table.widths[i] = { + width: w + }; + } + } + } + } + measureCanvas(node) { + let w = 0; + let h = 0; + for (let i = 0, l = node.canvas.length; i < l; i++) { + let vector = node.canvas[i]; + switch (vector.type) { + case 'ellipse': + w = Math.max(w, vector.x + vector.r1); + h = Math.max(h, vector.y + vector.r2); + break; + case 'rect': + w = Math.max(w, vector.x + vector.w); + h = Math.max(h, vector.y + vector.h); + break; + case 'line': + w = Math.max(w, vector.x1, vector.x2); + h = Math.max(h, vector.y1, vector.y2); + break; + case 'polyline': + for (let i2 = 0, l2 = vector.points.length; i2 < l2; i2++) { + w = Math.max(w, vector.points[i2].x); + h = Math.max(h, vector.points[i2].y); + } + break; + } + } + node._minWidth = node._maxWidth = w; + node._minHeight = node._maxHeight = h; + node._alignment = this.styleStack.getProperty('alignment'); + return node; + } + measureQr(node) { + node = qrEnc.measure(node); + node._alignment = this.styleStack.getProperty('alignment'); + return node; + } + measureAttachment(node) { + node._width = node.width || 7; + node._height = node.height || 18; + return node; + } +} +/* harmony default export */ const src_DocMeasure = (DocMeasure); +// EXTERNAL MODULE: ./node_modules/events/events.js +var events = __webpack_require__(4785); +;// ./src/DocumentContext.js + + + +/** + * A store for current x, y positions and available width/height. + * It facilitates column divisions and vertical sync + */ +class DocumentContext extends events.EventEmitter { + constructor() { + super(); + this.pages = []; + this.pageMargins = undefined; + this.x = undefined; + this.availableWidth = undefined; + this.availableHeight = undefined; + this.page = -1; + this.snapshots = []; + this.backgroundLength = []; + } + beginColumnGroup(marginXTopParent, bottomByPage, snakingColumns, columnGap, columnWidths) { + if (bottomByPage === void 0) { + bottomByPage = {}; + } + if (snakingColumns === void 0) { + snakingColumns = false; + } + if (columnGap === void 0) { + columnGap = 0; + } + if (columnWidths === void 0) { + columnWidths = null; + } + this.snapshots.push({ + x: this.x, + y: this.y, + availableHeight: this.availableHeight, + availableWidth: this.availableWidth, + page: this.page, + bottomByPage: bottomByPage ? bottomByPage : {}, + bottomMost: { + x: this.x, + y: this.y, + availableHeight: this.availableHeight, + availableWidth: this.availableWidth, + page: this.page + }, + lastColumnWidth: this.lastColumnWidth, + snakingColumns: snakingColumns, + gap: columnGap, + columnWidths: columnWidths + }); + this.lastColumnWidth = 0; + if (marginXTopParent) { + this.marginXTopParent = marginXTopParent; + } + } + updateBottomByPage() { + const lastSnapshot = this.snapshots[this.snapshots.length - 1]; + if (!lastSnapshot) { + return; + } + const lastPage = this.page; + let previousBottom = -Number.MIN_VALUE; + if (lastSnapshot.bottomByPage && lastSnapshot.bottomByPage[lastPage]) { + previousBottom = lastSnapshot.bottomByPage[lastPage]; + } + if (lastSnapshot.bottomByPage) { + lastSnapshot.bottomByPage[lastPage] = Math.max(previousBottom, this.y); + } + } + resetMarginXTopParent() { + this.marginXTopParent = null; + } + + /** + * Find the most recent (deepest) snaking column group snapshot. + * @returns {object|null} + */ + getSnakingSnapshot() { + for (let i = this.snapshots.length - 1; i >= 0; i--) { + if (this.snapshots[i].snakingColumns) { + return this.snapshots[i]; + } + } + return null; + } + inSnakingColumns() { + return !!this.getSnakingSnapshot(); + } + + /** + * Check if we're inside a nested non-snaking column group (e.g., a table row) + * within an outer snaking column group. This is used to prevent snaking-specific + * breaks inside table cells — the table's own page break mechanism should handle + * row breaks, and column breaks should happen between rows. + * @returns {boolean} + */ + isInNestedNonSnakingGroup() { + for (let i = this.snapshots.length - 1; i >= 0; i--) { + let snap = this.snapshots[i]; + if (snap.snakingColumns) { + return false; // Reached snaking snapshot without finding inner group + } + if (!snap.overflowed) { + return true; // Found non-snaking, non-overflowed inner group + } + } + return false; + } + beginColumn(width, offset, endingCell) { + // Find the correct snapshot for this column group. + // When a snaking column break (moveToNextColumn) occurs during inner column + // processing, overflowed snapshots may sit above this column group's snapshot. + // We need to skip past those to find the one from our beginColumnGroup call. + let saved = this.snapshots[this.snapshots.length - 1]; + if (saved && saved.overflowed) { + for (let i = this.snapshots.length - 1; i >= 0; i--) { + if (!this.snapshots[i].overflowed) { + saved = this.snapshots[i]; + break; + } + } + } + this.calculateBottomMost(saved, endingCell); + this.page = saved.page; + this.x = this.x + this.lastColumnWidth + (offset || 0); + this.y = saved.y; + this.availableWidth = width; //saved.availableWidth - offset; + this.availableHeight = saved.availableHeight; + this.lastColumnWidth = width; + } + calculateBottomMost(destContext, endingCell) { + if (endingCell) { + this.saveContextInEndingCell(endingCell); + } else { + destContext.bottomMost = bottomMostContext(this, destContext.bottomMost); + } + } + markEnding(endingCell, originalXOffset, discountY) { + this.page = endingCell._columnEndingContext.page; + this.x = endingCell._columnEndingContext.x + originalXOffset; + this.y = endingCell._columnEndingContext.y - discountY; + this.availableWidth = endingCell._columnEndingContext.availableWidth; + this.availableHeight = endingCell._columnEndingContext.availableHeight; + this.lastColumnWidth = endingCell._columnEndingContext.lastColumnWidth; + } + saveContextInEndingCell(endingCell) { + endingCell._columnEndingContext = { + page: this.page, + x: this.x, + y: this.y, + availableHeight: this.availableHeight, + availableWidth: this.availableWidth, + lastColumnWidth: this.lastColumnWidth + }; + } + completeColumnGroup(height, endingCell) { + let saved = this.snapshots.pop(); + + // Track the maximum bottom position across all columns (including overflowed). + // Critical for snaking: content after columns must appear below the tallest column. + let maxBottomY = this.y; + let maxBottomPage = this.page; + let maxBottomAvailableHeight = this.availableHeight; + + // Pop overflowed snapshots created by moveToNextColumn (snaking columns). + // Merge their bottomMost values to find the true maximum. + while (saved && saved.overflowed) { + let bm = bottomMostContext({ + page: maxBottomPage, + y: maxBottomY, + availableHeight: maxBottomAvailableHeight + }, saved.bottomMost || {}); + maxBottomPage = bm.page; + maxBottomY = bm.y; + maxBottomAvailableHeight = bm.availableHeight; + saved = this.snapshots.pop(); + } + if (!saved) { + return {}; + } + + // Apply the max bottom from all overflowed columns to this base snapshot + if (maxBottomPage > saved.bottomMost.page || maxBottomPage === saved.bottomMost.page && maxBottomY > saved.bottomMost.y) { + saved.bottomMost = { + x: saved.x, + y: maxBottomY, + page: maxBottomPage, + availableHeight: maxBottomAvailableHeight, + availableWidth: saved.availableWidth + }; + } + this.calculateBottomMost(saved, endingCell); + this.x = saved.x; + let y = saved.bottomMost.y; + if (height) { + if (saved.page === saved.bottomMost.page) { + if (saved.y + height > y) { + y = saved.y + height; + } + } else { + y += height; + } + } + this.y = y; + this.page = saved.bottomMost.page; + this.availableWidth = saved.availableWidth; + this.availableHeight = saved.bottomMost.availableHeight; + if (height) { + this.availableHeight -= y - saved.bottomMost.y; + } + if (height && saved.bottomMost.y - saved.y < height) { + this.height = height; + } else { + this.height = saved.bottomMost.y - saved.y; + } + this.lastColumnWidth = saved.lastColumnWidth; + return saved.bottomByPage; + } + + /** + * Move to the next column in a column group (snaking columns). + * Creates an overflowed snapshot to track that we've moved to the next column. + * @returns {object} Position info for the new column + */ + moveToNextColumn() { + let prevY = this.y; + let snakingSnapshot = this.getSnakingSnapshot(); + if (!snakingSnapshot) { + return { + prevY: prevY, + y: this.y + }; + } + + // Update snaking snapshot's bottomMost with current position BEFORE resetting. + // This captures where content reached in the current column (overflow point). + this.calculateBottomMost(snakingSnapshot, null); + + // Calculate new X position: move right by current column width + gap + let overflowCount = 0; + for (let i = this.snapshots.length - 1; i >= 0; i--) { + if (this.snapshots[i].overflowed) { + overflowCount++; + } else { + break; + } + } + let currentColumnWidth = snakingSnapshot.columnWidths && snakingSnapshot.columnWidths[overflowCount] || this.lastColumnWidth || this.availableWidth; + let nextColumnWidth = snakingSnapshot.columnWidths && snakingSnapshot.columnWidths[overflowCount + 1] || currentColumnWidth; + this.lastColumnWidth = nextColumnWidth; + let newX = this.x + (currentColumnWidth || 0) + (snakingSnapshot.gap || 0); + let newY = snakingSnapshot.y; + this.snapshots.push({ + x: newX, + y: newY, + availableHeight: snakingSnapshot.availableHeight, + availableWidth: nextColumnWidth, + page: this.page, + overflowed: true, + bottomMost: { + x: newX, + y: newY, + availableHeight: snakingSnapshot.availableHeight, + availableWidth: nextColumnWidth, + page: this.page + }, + lastColumnWidth: nextColumnWidth, + snakingColumns: true, + gap: snakingSnapshot.gap, + columnWidths: snakingSnapshot.columnWidths + }); + this.x = newX; + this.y = newY; + this.availableHeight = snakingSnapshot.availableHeight; + this.availableWidth = nextColumnWidth; + + // Sync non-overflowed inner snapshots (e.g. inner column groups for + // product/price rows) with the new snaking column position. + // Without this, inner beginColumn would read stale y/page/x values. + for (let i = this.snapshots.length - 2; i >= 0; i--) { + let snapshot = this.snapshots[i]; + if (snapshot.overflowed || snapshot.snakingColumns) { + break; // Stop at first overflowed or snaking snapshot + } + snapshot.x = newX; + snapshot.y = newY; + snapshot.page = this.page; + snapshot.availableHeight = snakingSnapshot.availableHeight; + if (snapshot.bottomMost) { + snapshot.bottomMost.x = newX; + snapshot.bottomMost.y = newY; + snapshot.bottomMost.page = this.page; + snapshot.bottomMost.availableHeight = snakingSnapshot.availableHeight; + } + } + return { + prevY: prevY, + y: this.y + }; + } + + /** + * Reset snaking column state when moving to a new page. + * Clears overflowed snapshots, resets X to left margin, sets width to first column, + * and syncs all snapshots to new page coordinates. + */ + resetSnakingColumnsForNewPage() { + let snakingSnapshot = this.getSnakingSnapshot(); + if (!snakingSnapshot) { + return; + } + let pageTopY = this.pageMargins.top; + let pageInnerHeight = this.getCurrentPage().pageSize.height - this.pageMargins.top - this.pageMargins.bottom; + + // When moving to new page, start at first column. + // Reset width to FIRST column width, not last column from previous page. + let firstColumnWidth = snakingSnapshot.columnWidths ? snakingSnapshot.columnWidths[0] : this.lastColumnWidth || this.availableWidth; + + // Clean up overflowed snapshots + while (this.snapshots.length > 1 && this.snapshots[this.snapshots.length - 1].overflowed) { + this.snapshots.pop(); + } + + // Reset X to start of first column (left margin) + if (this.marginXTopParent) { + this.x = this.pageMargins.left + this.marginXTopParent[0]; + } else { + this.x = this.pageMargins.left; + } + this.availableWidth = firstColumnWidth; + this.lastColumnWidth = firstColumnWidth; + + // Sync all snapshots to new page state. + // When page break occurs within snaking columns, update ALL snapshots + // (not just snaking column snapshots) to reflect new page coordinates. + // This ensures nested structures (like inner product/price columns) + // don't retain stale values that would cause layout corruption. + for (let i = 0; i < this.snapshots.length; i++) { + let snapshot = this.snapshots[i]; + let isSnakingSnapshot = !!snapshot.snakingColumns; + snapshot.x = this.x; + snapshot.y = isSnakingSnapshot ? pageTopY : this.y; + snapshot.availableHeight = isSnakingSnapshot ? pageInnerHeight : this.availableHeight; + snapshot.page = this.page; + if (snapshot.bottomMost) { + snapshot.bottomMost.x = this.x; + snapshot.bottomMost.y = isSnakingSnapshot ? pageTopY : this.y; + snapshot.bottomMost.availableHeight = isSnakingSnapshot ? pageInnerHeight : this.availableHeight; + snapshot.bottomMost.page = this.page; + } + } + } + addMargin(left, right) { + this.x += left; + this.availableWidth -= left + (right || 0); + } + moveDown(offset) { + this.y += offset; + this.availableHeight -= offset; + return this.availableHeight > 0; + } + initializePage() { + this.y = this.pageMargins.top; + this.availableHeight = this.getCurrentPage().pageSize.height - this.pageMargins.top - this.pageMargins.bottom; + const _this$pageSnapshot = this.pageSnapshot(), + pageCtx = _this$pageSnapshot.pageCtx, + isSnapshot = _this$pageSnapshot.isSnapshot; + pageCtx.availableWidth = this.getCurrentPage().pageSize.width - this.pageMargins.left - this.pageMargins.right; + if (isSnapshot && this.marginXTopParent) { + pageCtx.availableWidth -= this.marginXTopParent[0]; + pageCtx.availableWidth -= this.marginXTopParent[1]; + } + } + pageSnapshot() { + if (this.snapshots[0]) { + return { + pageCtx: this.snapshots[0], + isSnapshot: true + }; + } else { + return { + pageCtx: this, + isSnapshot: false + }; + } + } + moveTo(x, y) { + if (x !== undefined && x !== null) { + this.x = x; + this.availableWidth = this.getCurrentPage().pageSize.width - this.x - this.pageMargins.right; + } + if (y !== undefined && y !== null) { + this.y = y; + this.availableHeight = this.getCurrentPage().pageSize.height - this.y - this.pageMargins.bottom; + } + } + moveToRelative(x, y) { + if (x !== undefined && x !== null) { + this.x = this.x + x; + } + if (y !== undefined && y !== null) { + this.y = this.y + y; + } + } + beginDetachedBlock() { + this.snapshots.push({ + x: this.x, + y: this.y, + availableHeight: this.availableHeight, + availableWidth: this.availableWidth, + page: this.page, + lastColumnWidth: this.lastColumnWidth + }); + } + endDetachedBlock() { + let saved = this.snapshots.pop(); + this.x = saved.x; + this.y = saved.y; + this.availableWidth = saved.availableWidth; + this.availableHeight = saved.availableHeight; + this.page = saved.page; + this.lastColumnWidth = saved.lastColumnWidth; + } + moveToNextPage(pageOrientation) { + let nextPageIndex = this.page + 1; + let prevPage = this.page; + let prevY = this.y; + + // If we are in a column group + if (this.snapshots.length > 0) { + let lastSnapshot = this.snapshots[this.snapshots.length - 1]; + // We have to update prevY accordingly by also taking into consideration + // the 'y' of cells that don't break page + if (lastSnapshot.bottomMost && lastSnapshot.bottomMost.y) { + prevY = Math.max(this.y, lastSnapshot.bottomMost.y); + } + } + let createNewPage = nextPageIndex >= this.pages.length; + if (createNewPage) { + let currentAvailableWidth = this.availableWidth; + let currentPageOrientation = this.getCurrentPage().pageSize.orientation; + let pageSize = getPageSize(this.getCurrentPage(), pageOrientation); + this.addPage(pageSize, null, this.getCurrentPage().customProperties); + if (currentPageOrientation === pageSize.orientation) { + this.availableWidth = currentAvailableWidth; + } + } else { + this.page = nextPageIndex; + this.initializePage(); + } + return { + newPageCreated: createNewPage, + prevPage: prevPage, + prevY: prevY, + y: this.y + }; + } + addPage(pageSize, pageMargin, customProperties) { + if (pageMargin === void 0) { + pageMargin = null; + } + if (customProperties === void 0) { + customProperties = {}; + } + if (pageMargin !== null) { + this.pageMargins = pageMargin; + this.x = pageMargin.left; + this.availableWidth = pageSize.width - pageMargin.left - pageMargin.right; + } + let page = { + items: [], + pageSize: pageSize, + pageMargins: this.pageMargins, + customProperties: customProperties + }; + this.pages.push(page); + this.backgroundLength.push(0); + this.page = this.pages.length - 1; + this.initializePage(); + this.emit('pageAdded', page); + return page; + } + getCurrentPage() { + if (this.page < 0 || this.page >= this.pages.length) { + return null; + } + return this.pages[this.page]; + } + getCurrentPosition() { + let pageSize = this.getCurrentPage().pageSize; + let innerHeight = pageSize.height - this.pageMargins.top - this.pageMargins.bottom; + let innerWidth = pageSize.width - this.pageMargins.left - this.pageMargins.right; + return { + pageNumber: this.page + 1, + pageOrientation: pageSize.orientation, + pageInnerHeight: innerHeight, + pageInnerWidth: innerWidth, + left: this.x, + top: this.y, + verticalRatio: (this.y - this.pageMargins.top) / innerHeight, + horizontalRatio: (this.x - this.pageMargins.left) / innerWidth + }; + } +} +function pageOrientation(pageOrientationString, currentPageOrientation) { + if (pageOrientationString === undefined) { + return currentPageOrientation; + } else if (isString(pageOrientationString) && pageOrientationString.toLowerCase() === 'landscape') { + return 'landscape'; + } else { + return 'portrait'; + } +} +const getPageSize = (currentPage, newPageOrientation) => { + newPageOrientation = pageOrientation(newPageOrientation, currentPage.pageSize.orientation); + if (newPageOrientation !== currentPage.pageSize.orientation) { + return { + orientation: newPageOrientation, + width: currentPage.pageSize.height, + height: currentPage.pageSize.width + }; + } else { + return { + orientation: currentPage.pageSize.orientation, + width: currentPage.pageSize.width, + height: currentPage.pageSize.height + }; + } +}; +function bottomMostContext(c1, c2) { + let r; + if (c1.page > c2.page) { + r = c1; + } else if (c2.page > c1.page) { + r = c2; + } else { + r = c1.y > c2.y ? c1 : c2; + } + return { + page: r.page, + x: r.x, + y: r.y, + availableHeight: r.availableHeight, + availableWidth: r.availableWidth + }; +} +/* harmony default export */ const src_DocumentContext = (DocumentContext); +;// ./src/ElementWriter.js + + + + + +/** + * A line/vector writer, which adds elements to current page and sets + * their positions based on the context + */ +class ElementWriter extends events.EventEmitter { + /** + * @param {DocumentContext} context + */ + constructor(context) { + super(); + this._context = context; + this.contextStack = []; + } + + /** + * @returns {DocumentContext} + */ + context() { + return this._context; + } + addLine(line, dontUpdateContextPosition, index) { + let height = line.getHeight(); + let context = this.context(); + let page = context.getCurrentPage(); + let position = this.getCurrentPositionOnPage(); + if (context.availableHeight < height || !page) { + return false; + } + line.x = context.x + (line.x || 0); + line.y = context.y + (line.y || 0); + this.alignLine(line); + addPageItem(page, { + type: 'line', + item: line + }, index); + this.emit('lineAdded', line); + if (!dontUpdateContextPosition) { + context.moveDown(height); + } + return position; + } + alignLine(line) { + let width = this.context().availableWidth; + let lineWidth = line.getWidth(); + let alignment = line.inlines && line.inlines.length > 0 && line.inlines[0].alignment; + let offset = 0; + switch (alignment) { + case 'right': + offset = width - lineWidth; + break; + case 'center': + offset = (width - lineWidth) / 2; + break; + } + if (offset) { + line.x = (line.x || 0) + offset; + } + if (alignment === 'justify' && !line.newLineForced && !line.lastLineInParagraph && line.inlines.length > 1) { + let additionalSpacing = (width - lineWidth) / (line.inlines.length - 1); + for (let i = 1, l = line.inlines.length; i < l; i++) { + offset = i * additionalSpacing; + line.inlines[i].x += offset; + line.inlines[i].justifyShift = additionalSpacing; + } + } + } + addImage(image, index) { + let context = this.context(); + let page = context.getCurrentPage(); + let position = this.getCurrentPositionOnPage(); + if (!page || image.absolutePosition === undefined && context.availableHeight < image._height && page.items.length > 0) { + return false; + } + if (image._x === undefined) { + image._x = image.x || 0; + } + image.x = context.x + image._x; + image.y = context.y; + this.alignImage(image); + addPageItem(page, { + type: 'image', + item: image + }, index); + context.moveDown(image._height); + return position; + } + addCanvas(node, index) { + let context = this.context(); + let page = context.getCurrentPage(); + let positions = []; + let height = node._minHeight; + if (!page || node.absolutePosition === undefined && context.availableHeight < height) { + // TODO: support for canvas larger than a page + // TODO: support for other overflow methods + + return false; + } + this.alignCanvas(node); + node.canvas.forEach(function (vector) { + let position = this.addVector(vector, false, false, index); + positions.push(position); + if (index !== undefined) { + index++; + } + }, this); + context.moveDown(height); + return positions; + } + addSVG(image, index) { + // TODO: same as addImage + let context = this.context(); + let page = context.getCurrentPage(); + let position = this.getCurrentPositionOnPage(); + if (!page || image.absolutePosition === undefined && context.availableHeight < image._height && page.items.length > 0) { + return false; + } + if (image._x === undefined) { + image._x = image.x || 0; + } + image.x = context.x + image._x; + image.y = context.y; + this.alignImage(image); + addPageItem(page, { + type: 'svg', + item: image + }, index); + context.moveDown(image._height); + return position; + } + addQr(qr, index) { + let context = this.context(); + let page = context.getCurrentPage(); + let position = this.getCurrentPositionOnPage(); + if (!page || qr.absolutePosition === undefined && context.availableHeight < qr._height) { + return false; + } + if (qr._x === undefined) { + qr._x = qr.x || 0; + } + qr.x = context.x + qr._x; + qr.y = context.y; + this.alignImage(qr); + for (let i = 0, l = qr._canvas.length; i < l; i++) { + let vector = qr._canvas[i]; + vector.x += qr.x; + vector.y += qr.y; + this.addVector(vector, true, true, index); + } + context.moveDown(qr._height); + return position; + } + addAttachment(attachment, index) { + let context = this.context(); + let page = context.getCurrentPage(); + let position = this.getCurrentPositionOnPage(); + if (!page || attachment.absolutePosition === undefined && context.availableHeight < attachment._height && page.items.length > 0) { + return false; + } + if (attachment._x === undefined) { + attachment._x = attachment.x || 0; + } + attachment.x = context.x + attachment._x; + attachment.y = context.y; + addPageItem(page, { + type: 'attachment', + item: attachment + }, index); + context.moveDown(attachment._height); + return position; + } + alignImage(image) { + let width = this.context().availableWidth; + let imageWidth = image._minWidth; + let offset = 0; + switch (image._alignment) { + case 'right': + offset = width - imageWidth; + break; + case 'center': + offset = (width - imageWidth) / 2; + break; + } + if (offset) { + image.x = (image.x || 0) + offset; + } + } + alignCanvas(node) { + let width = this.context().availableWidth; + let canvasWidth = node._minWidth; + let offset = 0; + switch (node._alignment) { + case 'right': + offset = width - canvasWidth; + break; + case 'center': + offset = (width - canvasWidth) / 2; + break; + } + if (offset) { + node.canvas.forEach(vector => { + offsetVector(vector, offset, 0); + }); + } + } + addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) { + let context = this.context(); + let page = context.getCurrentPage(); + if (isNumber(forcePage)) { + page = context.pages[forcePage]; + } + let position = this.getCurrentPositionOnPage(); + if (page) { + offsetVector(vector, ignoreContextX ? 0 : context.x, ignoreContextY ? 0 : context.y); + addPageItem(page, { + type: 'vector', + item: vector + }, index); + return position; + } + } + beginClip(width, height) { + let ctx = this.context(); + let page = ctx.getCurrentPage(); + page.items.push({ + type: 'beginClip', + item: { + x: ctx.x, + y: ctx.y, + width: width, + height: height + } + }); + return true; + } + endClip() { + let ctx = this.context(); + let page = ctx.getCurrentPage(); + page.items.push({ + type: 'endClip' + }); + return true; + } + beginVerticalAlignment(verticalAlignment) { + let page = this.context().getCurrentPage(); + let item = { + type: 'beginVerticalAlignment', + item: { + verticalAlignment: verticalAlignment + } + }; + page.items.push(item); + return item; + } + endVerticalAlignment(verticalAlignment) { + let page = this.context().getCurrentPage(); + let item = { + type: 'endVerticalAlignment', + item: { + verticalAlignment: verticalAlignment + } + }; + page.items.push(item); + return item; + } + addFragment(block, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition) { + let ctx = this.context(); + let page = ctx.getCurrentPage(); + if (!useBlockXOffset && block.height > ctx.availableHeight) { + return false; + } + block.items.forEach(item => { + switch (item.type) { + case 'line': + var l = item.item.clone(); + if (l._node) { + l._node.positions[0].pageNumber = ctx.page + 1; + } + l.x = (l.x || 0) + (useBlockXOffset ? block.xOffset || 0 : ctx.x); + l.y = (l.y || 0) + (useBlockYOffset ? block.yOffset || 0 : ctx.y); + page.items.push({ + type: 'line', + item: l + }); + break; + case 'vector': + var v = pack(item.item); + offsetVector(v, useBlockXOffset ? block.xOffset || 0 : ctx.x, useBlockYOffset ? block.yOffset || 0 : ctx.y); + if (v._isFillColorFromUnbreakable) { + // If the item is a fillColor from an unbreakable block + // We have to add it at the beginning of the items body array of the page + delete v._isFillColorFromUnbreakable; + const endOfBackgroundItemsIndex = ctx.backgroundLength[ctx.page]; + page.items.splice(endOfBackgroundItemsIndex, 0, { + type: 'vector', + item: v + }); + } else { + page.items.push({ + type: 'vector', + item: v + }); + } + break; + case 'image': + case 'svg': + case 'beginClip': + case 'endClip': + case 'beginVerticalAlignment': + case 'endVerticalAlignment': + var img = pack(item.item); + img.x = (img.x || 0) + (useBlockXOffset ? block.xOffset || 0 : ctx.x); + img.y = (img.y || 0) + (useBlockYOffset ? block.yOffset || 0 : ctx.y); + page.items.push({ + type: item.type, + item: img + }); + break; + } + }); + if (!dontUpdateContextPosition) { + ctx.moveDown(block.height); + } + return true; + } + + /** + * Pushes the provided context onto the stack or creates a new one + * + * pushContext(context) - pushes the provided context and makes it current + * pushContext(width, height) - creates and pushes a new context with the specified width and height + * pushContext() - creates a new context for unbreakable blocks (with current availableWidth and full-page-height) + * + * @param {DocumentContext|number} contextOrWidth + * @param {number} height + */ + pushContext(contextOrWidth, height) { + if (contextOrWidth === undefined) { + height = this.context().getCurrentPage().height - this.context().pageMargins.top - this.context().pageMargins.bottom; + contextOrWidth = this.context().availableWidth; + } + if (isNumber(contextOrWidth)) { + let width = contextOrWidth; + contextOrWidth = new src_DocumentContext(); + contextOrWidth.addPage({ + width: width, + height: height + }, { + left: 0, + right: 0, + top: 0, + bottom: 0 + }); + } + this.contextStack.push(this.context()); + this._context = contextOrWidth; + } + popContext() { + this._context = this.contextStack.pop(); + } + getCurrentPositionOnPage() { + return (this.contextStack[0] || this.context()).getCurrentPosition(); + } +} +function addPageItem(page, item, index) { + if (index === null || index === undefined || index < 0 || index > page.items.length) { + page.items.push(item); + } else { + page.items.splice(index, 0, item); + } +} +/* harmony default export */ const src_ElementWriter = (ElementWriter); +;// ./src/standardPageSizes.js +/* harmony default export */ const standardPageSizes = ({ + '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.40, 209.76], + A9: [104.88, 147.40], + A10: [73.70, 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.90, 708.66], + B6: [354.33, 498.90], + 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.80, 3458.27], + RA1: [1729.13, 2437.80], + RA2: [1218.90, 1729.13], + RA3: [864.57, 1218.90], + 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.80, 907.09], + EXECUTIVE: [521.86, 756.00], + FOLIO: [612.00, 936.00], + LEGAL: [612.00, 1008.00], + LETTER: [612.00, 792.00], + TABLOID: [792.00, 1224.00] +}); +;// ./src/PageSize.js + + +function normalizePageSize(pageSize, pageOrientation) { + function isNeedSwapPageSizes(pageOrientation) { + if (isString(pageOrientation)) { + pageOrientation = pageOrientation.toLowerCase(); + return pageOrientation === 'portrait' && size.width > size.height || pageOrientation === 'landscape' && size.width < size.height; + } + return false; + } + function pageSizeToWidthAndHeight(pageSize) { + if (isString(pageSize)) { + let size = standardPageSizes[pageSize.toUpperCase()]; + if (!size) { + throw new Error(`Page size ${pageSize} not recognized`); + } + return { + width: size[0], + height: size[1] + }; + } + return pageSize; + } + + // if pageSize.height is set to auto, set the height to infinity so there are no page breaks. + if (pageSize && pageSize.height === 'auto') { + pageSize.height = Infinity; + } + let size = pageSizeToWidthAndHeight(pageSize || 'A4'); + if (isNeedSwapPageSizes(pageOrientation)) { + // swap page sizes + size = { + width: size.height, + height: size.width + }; + } + size.orientation = size.width > size.height ? 'landscape' : 'portrait'; + return size; +} +function normalizePageMargin(margin) { + if (isNumber(margin)) { + margin = { + left: margin, + right: margin, + top: margin, + bottom: margin + }; + } else if (Array.isArray(margin)) { + if (margin.length === 2) { + margin = { + left: margin[0], + top: margin[1], + right: margin[0], + bottom: margin[1] + }; + } else if (margin.length === 4) { + margin = { + left: margin[0], + top: margin[1], + right: margin[2], + bottom: margin[3] + }; + } else { + throw new Error('Invalid pageMargins definition'); + } + } + return margin; +} +;// ./src/PageElementWriter.js + + + + +/** + * An extended ElementWriter which can handle: + * - page-breaks (it adds new pages when there's not enough space left), + * - repeatable fragments (like table-headers, which are repeated everytime + * a page-break occurs) + * - transactions (used for unbreakable-blocks when we want to make sure + * whole block will be rendered on the same page) + */ +class PageElementWriter extends src_ElementWriter { + /** + * @param {DocumentContext} context + */ + constructor(context) { + super(context); + this.transactionLevel = 0; + this.repeatables = []; + } + addLine(line, dontUpdateContextPosition, index) { + return this._fitOnPage(() => super.addLine(line, dontUpdateContextPosition, index)); + } + addImage(image, index) { + return this._fitOnPage(() => super.addImage(image, index)); + } + addCanvas(image, index) { + return this._fitOnPage(() => super.addCanvas(image, index)); + } + addSVG(image, index) { + return this._fitOnPage(() => super.addSVG(image, index)); + } + addQr(qr, index) { + return this._fitOnPage(() => super.addQr(qr, index)); + } + addAttachment(attachment, index) { + return this._fitOnPage(() => super.addAttachment(attachment, index)); + } + addVector(vector, ignoreContextX, ignoreContextY, index, forcePage) { + return super.addVector(vector, ignoreContextX, ignoreContextY, index, forcePage); + } + beginClip(width, height) { + return super.beginClip(width, height); + } + endClip() { + return super.endClip(); + } + beginVerticalAlignment(verticalAlignment) { + return super.beginVerticalAlignment(verticalAlignment); + } + endVerticalAlignment(verticalAlignment) { + return super.endVerticalAlignment(verticalAlignment); + } + addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition) { + return this._fitOnPage(() => super.addFragment(fragment, useBlockXOffset, useBlockYOffset, dontUpdateContextPosition)); + } + moveToNextPage(pageOrientation) { + let nextPage = this.context().moveToNextPage(pageOrientation); + + // moveToNextPage is called multiple times for table, because is called for each column + // and repeatables are inserted only in the first time. If columns are used, is needed + // call for table in first column and then for table in the second column (is other repeatables). + this.repeatables.forEach(function (rep) { + if (rep.insertedOnPages[this.context().page] === undefined) { + rep.insertedOnPages[this.context().page] = true; + this.addFragment(rep, true); + } else { + this.context().moveDown(rep.height); + } + }, this); + this.emit('pageChanged', { + prevPage: nextPage.prevPage, + prevY: nextPage.prevY, + y: this.context().y + }); + } + addPage(pageSize, pageOrientation, pageMargin, customProperties) { + if (customProperties === void 0) { + customProperties = {}; + } + let prevPage = this.page; + let prevY = this.y; + this.context().addPage(normalizePageSize(pageSize, pageOrientation), normalizePageMargin(pageMargin), customProperties); + this.emit('pageChanged', { + prevPage: prevPage, + prevY: prevY, + y: this.context().y + }); + } + beginUnbreakableBlock(width, height) { + if (this.transactionLevel++ === 0) { + this.originalX = this.context().x; + this.pushContext(width, height); + } + } + commitUnbreakableBlock(forcedX, forcedY) { + if (--this.transactionLevel === 0) { + let unbreakableContext = this.context(); + this.popContext(); + let nbPages = unbreakableContext.pages.length; + if (nbPages > 0) { + // no support for multi-page unbreakableBlocks + let fragment = unbreakableContext.pages[0]; + fragment.xOffset = forcedX; + fragment.yOffset = forcedY; + + //TODO: vectors can influence height in some situations + if (nbPages > 1) { + // on out-of-context blocs (headers, footers, background) height should be the whole DocumentContext height + if (forcedX !== undefined || forcedY !== undefined) { + fragment.height = unbreakableContext.getCurrentPage().pageSize.height - unbreakableContext.pageMargins.top - unbreakableContext.pageMargins.bottom; + } else { + fragment.height = this.context().getCurrentPage().pageSize.height - this.context().pageMargins.top - this.context().pageMargins.bottom; + for (let i = 0, l = this.repeatables.length; i < l; i++) { + fragment.height -= this.repeatables[i].height; + } + } + } else { + fragment.height = unbreakableContext.y; + } + if (forcedX !== undefined || forcedY !== undefined) { + super.addFragment(fragment, true, true, true); + } else { + this.addFragment(fragment); + } + } + } + } + currentBlockToRepeatable() { + let unbreakableContext = this.context(); + let rep = { + items: [] + }; + unbreakableContext.pages[0].items.forEach(item => { + rep.items.push(item); + }); + rep.xOffset = this.originalX; + + //TODO: vectors can influence height in some situations + rep.height = unbreakableContext.y; + rep.insertedOnPages = []; + return rep; + } + pushToRepeatables(rep) { + this.repeatables.push(rep); + } + popFromRepeatables() { + this.repeatables.pop(); + } + + /** + * Move to the next column in a column group (snaking columns). + * Handles repeatables and emits columnChanged event. + */ + moveToNextColumn() { + let nextColumn = this.context().moveToNextColumn(); + + // Handle repeatables (like table headers) for the new column + this.repeatables.forEach(function (rep) { + // In snaking columns, we WANT headers to repeat. + // However, in Standard Page Breaks, headers are drawn using useBlockXOffset=true (original absolute X). + // This works for page breaks because margins are consistent. + // In Snaking Columns, the X position changes for each column. + // If we use true, the header is drawn at the *original* X position (Col 1), overlapping/invisible. + // We MUST use false to force drawing relative to the CURRENT context X (new column start). + this.addFragment(rep, false); + }, this); + this.emit('columnChanged', { + prevY: nextColumn.prevY, + y: this.context().y + }); + } + + /** + * Check if currently in a column group that can move to next column. + * Only returns true if snakingColumns is enabled for the column group. + * @returns {boolean} + */ + canMoveToNextColumn() { + let ctx = this.context(); + let snakingSnapshot = ctx.getSnakingSnapshot(); + if (snakingSnapshot) { + // Check if we're inside a nested (non-snaking) column group. + // If so, don't allow a snaking column move — it would corrupt + // the inner row's layout (e.g. product name in col 1, price in col 2). + // The inner row should complete via normal page break instead. + for (let i = ctx.snapshots.length - 1; i >= 0; i--) { + let snap = ctx.snapshots[i]; + if (snap.snakingColumns) { + break; // Reached the snaking snapshot, no inner groups found + } + if (!snap.overflowed) { + return false; // Found a non-snaking, non-overflowed inner group + } + } + let overflowCount = 0; + for (let i = ctx.snapshots.length - 1; i >= 0; i--) { + if (ctx.snapshots[i].overflowed) { + overflowCount++; + } else { + break; + } + } + if (snakingSnapshot.columnWidths && overflowCount >= snakingSnapshot.columnWidths.length - 1) { + return false; + } + let currentColumnWidth = ctx.availableWidth || ctx.lastColumnWidth || 0; + let nextColumnWidth = snakingSnapshot.columnWidths ? snakingSnapshot.columnWidths[overflowCount + 1] : currentColumnWidth; + let nextX = ctx.x + currentColumnWidth + (snakingSnapshot.gap || 0); + let page = ctx.getCurrentPage(); + let pageWidth = page.pageSize.width; + let rightMargin = page.pageMargins ? page.pageMargins.right : 0; + let parentRightMargin = ctx.marginXTopParent ? ctx.marginXTopParent[1] : 0; + let rightBoundary = pageWidth - rightMargin - parentRightMargin; + return nextX + nextColumnWidth <= rightBoundary + 1; + } + return false; + } + _fitOnPage(addFct) { + let position = addFct(); + if (!position) { + if (this.canMoveToNextColumn()) { + this.moveToNextColumn(); + position = addFct(); + } + if (!position) { + let ctx = this.context(); + let snakingSnapshot = ctx.getSnakingSnapshot(); + if (snakingSnapshot) { + if (ctx.isInNestedNonSnakingGroup()) { + // Inside a table cell within snaking columns — use standard page break. + // Don't reset snaking state; the table handles its own breaks. + // Column breaks happen between rows in processTable instead. + this.moveToNextPage(); + } else { + this.moveToNextPage(); + + // Save lastColumnWidth before reset — if we're inside a nested + // column group (e.g. product/price row), the reset would overwrite + // it with the snaking column width, corrupting inner column layout. + let savedLastColumnWidth = ctx.lastColumnWidth; + ctx.resetSnakingColumnsForNewPage(); + ctx.lastColumnWidth = savedLastColumnWidth; + } + position = addFct(); + } else { + while (ctx.snapshots.length > 0 && ctx.snapshots[ctx.snapshots.length - 1].overflowed) { + let popped = ctx.snapshots.pop(); + let prevSnapshot = ctx.snapshots[ctx.snapshots.length - 1]; + if (prevSnapshot) { + ctx.x = prevSnapshot.x; + ctx.y = prevSnapshot.y; + ctx.availableHeight = prevSnapshot.availableHeight; + ctx.availableWidth = popped.availableWidth; + ctx.lastColumnWidth = prevSnapshot.lastColumnWidth; + } + } + this.moveToNextPage(); + position = addFct(); + } + } + } + return position; + } +} +/* harmony default export */ const src_PageElementWriter = (PageElementWriter); +;// ./src/TableProcessor.js + + +const PAGE_BREAK_VALUES = new Set(['before', 'beforeOdd', 'beforeEven', 'after', 'afterOdd', 'afterEven']); +const hasExplicitPageBreak = cell => { + if (!cell || typeof cell !== 'object') { + return false; + } + return PAGE_BREAK_VALUES.has(cell.pageBreak); +}; +class TableProcessor { + constructor(tableNode) { + this.tableNode = tableNode; + this._isCurrentRowUnbreakable = false; + } + beginTable(writer) { + const getTableInnerContentWidth = () => { + let width = 0; + tableNode.table.widths.forEach(w => { + width += w._calcWidth; + }); + return width; + }; + const prepareRowSpanData = () => { + let rsd = []; + let x = 0; + let lastWidth; + rsd.push({ + left: 0, + rowSpan: 0 + }); + for (let i = 0, l = this.tableNode.table.body[0].length; i < l; i++) { + let paddings = this.layout.paddingLeft(i, this.tableNode) + this.layout.paddingRight(i, this.tableNode); + let lBorder = this.layout.vLineWidth(i, this.tableNode); + lastWidth = paddings + lBorder + this.tableNode.table.widths[i]._calcWidth; + rsd[rsd.length - 1].width = lastWidth; + x += lastWidth; + rsd.push({ + left: x, + rowSpan: 0, + width: 0 + }); + } + return rsd; + }; + + // Iterate through all cells. If the current cell is the start of a + // rowSpan/colSpan, update the border property of the cells on its + // bottom/right accordingly. This is needed since each iteration of the + // line-drawing loops draws lines for a single cell, not for an entire + // rowSpan/colSpan. + const prepareCellBorders = body => { + for (let rowIndex = 0; rowIndex < body.length; rowIndex++) { + let row = body[rowIndex]; + for (let colIndex = 0; colIndex < row.length; colIndex++) { + let cell = row[colIndex]; + if (cell.border) { + let rowSpan = cell.rowSpan || 1; + let colSpan = cell.colSpan || 1; + for (let rowOffset = 0; rowOffset < rowSpan; rowOffset++) { + // set left border + if (cell.border[0] !== undefined && rowOffset > 0) { + setBorder(rowIndex + rowOffset, colIndex, 0, cell.border[0]); + } + + // set right border + if (cell.border[2] !== undefined) { + setBorder(rowIndex + rowOffset, colIndex + colSpan - 1, 2, cell.border[2]); + } + } + for (let colOffset = 0; colOffset < colSpan; colOffset++) { + // set top border + if (cell.border[1] !== undefined && colOffset > 0) { + setBorder(rowIndex, colIndex + colOffset, 1, cell.border[1]); + } + + // set bottom border + if (cell.border[3] !== undefined) { + setBorder(rowIndex + rowSpan - 1, colIndex + colOffset, 3, cell.border[3]); + } + } + } + } + } + + // helper function to set the border for a given cell + function setBorder(rowIndex, colIndex, borderIndex, borderValue) { + let cell = body[rowIndex][colIndex]; + cell.border = cell.border || {}; + cell.border[borderIndex] = borderValue; + } + }; + let tableNode; + let availableWidth; + tableNode = this.tableNode; + this.offsets = tableNode._offsets; + this.layout = tableNode._layout; + availableWidth = writer.context().availableWidth - this.offsets.total; + columnCalculator.buildColumnWidths(tableNode.table.widths, availableWidth, this.offsets.total, tableNode); + this.tableWidth = tableNode._offsets.total + getTableInnerContentWidth(); + this.rowSpanData = prepareRowSpanData(); + this.cleanUpRepeatables = false; + + // headersRows and rowsWithoutPageBreak (headerRows + keepWithHeaderRows) + this.headerRows = 0; + this.rowsWithoutPageBreak = 0; + const headerRows = tableNode.table.headerRows; + if (isPositiveInteger(headerRows)) { + this.headerRows = headerRows; + if (this.headerRows > tableNode.table.body.length) { + throw new Error(`Too few rows in the table. Property headerRows requires at least ${this.headerRows}, contains only ${tableNode.table.body.length}`); + } + this.rowsWithoutPageBreak = this.headerRows; + const keepWithHeaderRows = tableNode.table.keepWithHeaderRows; + if (isPositiveInteger(keepWithHeaderRows)) { + this.rowsWithoutPageBreak += keepWithHeaderRows; + } + } + this.dontBreakRows = tableNode.table.dontBreakRows || false; + if (this.rowsWithoutPageBreak || this.dontBreakRows) { + writer.beginUnbreakableBlock(); + // Draw the top border of the table + this.drawHorizontalLine(0, writer); + if (this.rowsWithoutPageBreak && this.dontBreakRows) { + // We just increase the value of transactionLevel + writer.beginUnbreakableBlock(); + } + } + + // update the border properties of all cells before drawing any lines + prepareCellBorders(this.tableNode.table.body); + } + onRowBreak(rowIndex, writer) { + return () => { + let offset = this.rowPaddingTop + (!this.headerRows ? this.topLineWidth : 0); + writer.context().availableHeight -= this.reservedAtBottom; + writer.context().moveDown(offset); + }; + } + beginRow(rowIndex, writer) { + this.topLineWidth = this.layout.hLineWidth(rowIndex, this.tableNode); + this.rowPaddingTop = this.layout.paddingTop(rowIndex, this.tableNode); + this.bottomLineWidth = this.layout.hLineWidth(rowIndex + 1, this.tableNode); + this.rowPaddingBottom = this.layout.paddingBottom(rowIndex, this.tableNode); + this.rowCallback = this.onRowBreak(rowIndex, writer); + writer.addListener('pageChanged', this.rowCallback); + if (rowIndex == 0 && !this.dontBreakRows && !this.rowsWithoutPageBreak) { + // We store the 'y' to draw later and if necessary the top border of the table + this._tableTopBorderY = writer.context().y; + writer.context().moveDown(this.topLineWidth); + } + this.rowTopPageY = writer.context().y + this.rowPaddingTop; + const rowCells = this.tableNode.table.body[rowIndex] || []; + const rowHasPageBreak = rowCells.some(hasExplicitPageBreak); + this._isCurrentRowUnbreakable = this.dontBreakRows && rowIndex > 0 && !rowHasPageBreak; + if (this._isCurrentRowUnbreakable) { + writer.beginUnbreakableBlock(); + } + this.rowTopY = writer.context().y; + this.reservedAtBottom = this.bottomLineWidth + this.rowPaddingBottom; + writer.context().availableHeight -= this.reservedAtBottom; + writer.context().moveDown(this.rowPaddingTop); + } + drawHorizontalLine(lineIndex, writer, overrideY, moveDown, forcePage) { + if (moveDown === void 0) { + moveDown = true; + } + let lineWidth = this.layout.hLineWidth(lineIndex, this.tableNode); + if (lineWidth) { + let style = this.layout.hLineStyle(lineIndex, this.tableNode); + let dash; + if (style && style.dash) { + dash = style.dash; + } + let offset = lineWidth / 2; + let currentLine = null; + let body = this.tableNode.table.body; + let cellAbove; + let currentCell; + let rowCellAbove; + for (let i = 0, l = this.rowSpanData.length; i < l; i++) { + let data = this.rowSpanData[i]; + let shouldDrawLine = !data.rowSpan; + let borderColor = null; + + // draw only if the current cell requires a top border or the cell in the + // row above requires a bottom border + if (shouldDrawLine && i < l - 1) { + var topBorder = false, + bottomBorder = false, + rowBottomBorder = false; + + // the cell in the row above + if (lineIndex > 0) { + cellAbove = body[lineIndex - 1][i]; + bottomBorder = cellAbove.border ? cellAbove.border[3] : this.layout.defaultBorder; + if (bottomBorder && cellAbove.borderColor) { + borderColor = cellAbove.borderColor[3]; + } + } + + // the current cell + if (lineIndex < body.length) { + currentCell = body[lineIndex][i]; + topBorder = currentCell.border ? currentCell.border[1] : this.layout.defaultBorder; + if (topBorder && borderColor == null && currentCell.borderColor) { + borderColor = currentCell.borderColor[1]; + } + } + shouldDrawLine = topBorder || bottomBorder; + } + if (cellAbove && cellAbove._rowSpanCurrentOffset) { + rowCellAbove = body[lineIndex - 1 - cellAbove._rowSpanCurrentOffset][i]; + rowBottomBorder = rowCellAbove && rowCellAbove.border ? rowCellAbove.border[3] : this.layout.defaultBorder; + if (rowBottomBorder && rowCellAbove && rowCellAbove.borderColor) { + borderColor = rowCellAbove.borderColor[3]; + } + } + if (borderColor == null) { + borderColor = typeof this.layout.hLineColor === 'function' ? this.layout.hLineColor(lineIndex, this.tableNode, i) : this.layout.hLineColor; + } + if (!currentLine && shouldDrawLine) { + currentLine = { + left: data.left, + width: 0 + }; + } + if (shouldDrawLine) { + let colSpanIndex = 0; + if (rowCellAbove && rowCellAbove.colSpan && rowBottomBorder) { + while (rowCellAbove.colSpan > colSpanIndex) { + currentLine.width += this.rowSpanData[i + colSpanIndex++].width || 0; + } + i += colSpanIndex - 1; + } else if (cellAbove && cellAbove.colSpan && bottomBorder) { + while (cellAbove.colSpan > colSpanIndex) { + currentLine.width += this.rowSpanData[i + colSpanIndex++].width || 0; + } + i += colSpanIndex - 1; + } else if (currentCell && currentCell.colSpan && topBorder) { + while (currentCell.colSpan > colSpanIndex) { + currentLine.width += this.rowSpanData[i + colSpanIndex++].width || 0; + } + i += colSpanIndex - 1; + } else { + currentLine.width += this.rowSpanData[i].width || 0; + } + } + let y = (overrideY || 0) + offset; + if (shouldDrawLine) { + if (currentLine && currentLine.width) { + writer.addVector({ + type: 'line', + x1: currentLine.left, + x2: currentLine.left + currentLine.width, + y1: y, + y2: y, + lineWidth: lineWidth, + dash: dash, + lineColor: borderColor + }, false, isNumber(overrideY), null, forcePage); + currentLine = null; + cellAbove = null; + currentCell = null; + rowCellAbove = null; + } + } + } + if (moveDown) { + writer.context().moveDown(lineWidth); + } + } + } + drawVerticalLine(x, y0, y1, vLineColIndex, writer, vLineRowIndex, beforeVLineColIndex) { + let width = this.layout.vLineWidth(vLineColIndex, this.tableNode); + if (width === 0) { + return; + } + let style = this.layout.vLineStyle(vLineColIndex, this.tableNode); + let dash; + if (style && style.dash) { + dash = style.dash; + } + let body = this.tableNode.table.body; + let cellBefore; + let currentCell; + let borderColor; + + // the cell in the col before + if (vLineColIndex > 0) { + cellBefore = body[vLineRowIndex][beforeVLineColIndex]; + if (cellBefore && cellBefore.borderColor) { + if (cellBefore.border ? cellBefore.border[2] : this.layout.defaultBorder) { + borderColor = cellBefore.borderColor[2]; + } + } + } + + // the current cell + if (borderColor == null && vLineColIndex < body.length) { + currentCell = body[vLineRowIndex][vLineColIndex]; + if (currentCell && currentCell.borderColor) { + if (currentCell.border ? currentCell.border[0] : this.layout.defaultBorder) { + borderColor = currentCell.borderColor[0]; + } + } + } + if (borderColor == null && cellBefore && cellBefore._rowSpanCurrentOffset) { + let rowCellBeforeAbove = body[vLineRowIndex - cellBefore._rowSpanCurrentOffset][beforeVLineColIndex]; + if (rowCellBeforeAbove.borderColor) { + if (rowCellBeforeAbove.border ? rowCellBeforeAbove.border[2] : this.layout.defaultBorder) { + borderColor = rowCellBeforeAbove.borderColor[2]; + } + } + } + if (borderColor == null && currentCell && currentCell._rowSpanCurrentOffset) { + let rowCurrentCellAbove = body[vLineRowIndex - currentCell._rowSpanCurrentOffset][vLineColIndex]; + if (rowCurrentCellAbove.borderColor) { + if (rowCurrentCellAbove.border ? rowCurrentCellAbove.border[2] : this.layout.defaultBorder) { + borderColor = rowCurrentCellAbove.borderColor[2]; + } + } + } + if (borderColor == null) { + borderColor = typeof this.layout.vLineColor === 'function' ? this.layout.vLineColor(vLineColIndex, this.tableNode, vLineRowIndex) : this.layout.vLineColor; + } + writer.addVector({ + type: 'line', + x1: x + width / 2, + x2: x + width / 2, + y1: y0, + y2: y1, + lineWidth: width, + dash: dash, + lineColor: borderColor + }, false, true); + } + endTable(writer) { + if (this.cleanUpRepeatables) { + writer.popFromRepeatables(); + } + } + endRow(rowIndex, writer, pageBreaks) { + const getLineXs = () => { + let result = []; + let cols = 0; + for (let i = 0, l = this.tableNode.table.body[rowIndex].length; i < l; i++) { + if (!cols) { + result.push({ + x: this.rowSpanData[i].left, + index: i + }); + let item = this.tableNode.table.body[rowIndex][i]; + cols = item._colSpan || item.colSpan || 0; + } + if (cols > 0) { + cols--; + } + } + result.push({ + x: this.rowSpanData[this.rowSpanData.length - 1].left, + index: this.rowSpanData.length - 1 + }); + return result; + }; + writer.removeListener('pageChanged', this.rowCallback); + writer.context().moveDown(this.layout.paddingBottom(rowIndex, this.tableNode)); + writer.context().availableHeight += this.reservedAtBottom; + let endingPage = writer.context().page; + let endingY = writer.context().y; + let xs = getLineXs(); + let ys = []; + let hasBreaks = pageBreaks && pageBreaks.length > 0; + let body = this.tableNode.table.body; + ys.push({ + y0: this.rowTopY, + page: hasBreaks ? pageBreaks[0].prevPage : endingPage + }); + if (hasBreaks) { + for (let i = 0, l = pageBreaks.length; i < l; i++) { + let pageBreak = pageBreaks[i]; + ys[ys.length - 1].y1 = pageBreak.prevY; + ys.push({ + y0: pageBreak.y, + page: pageBreak.prevPage + 1 + }); + } + } + ys[ys.length - 1].y1 = endingY; + let skipOrphanePadding = ys[0].y1 - ys[0].y0 === this.rowPaddingTop; + if (rowIndex === 0 && !skipOrphanePadding && !this.rowsWithoutPageBreak && !this.dontBreakRows) { + // Draw the top border of the table + let pageTableStartedAt = null; + if (pageBreaks && pageBreaks.length > 0) { + // Get the page where table started at + pageTableStartedAt = pageBreaks[0].prevPage; + } + this.drawHorizontalLine(0, writer, this._tableTopBorderY, false, pageTableStartedAt); + } + for (let yi = skipOrphanePadding ? 1 : 0, yl = ys.length; yi < yl; yi++) { + let willBreak = yi < ys.length - 1; + let rowBreakWithoutHeader = yi > 0 && !this.headerRows; + let hzLineOffset = rowBreakWithoutHeader ? 0 : this.topLineWidth; + let y1 = ys[yi].y0; + let y2 = ys[yi].y1; + if (willBreak) { + y2 = y2 + this.rowPaddingBottom; + } + if (writer.context().page != ys[yi].page) { + writer.context().page = ys[yi].page; + + //TODO: buggy, availableHeight should be updated on every pageChanged event + // TableProcessor should be pageChanged listener, instead of processRow + this.reservedAtBottom = 0; + } + + // Draw horizontal lines before the vertical lines so they are not overridden + if (willBreak && this.layout.hLineWhenBroken !== false) { + this.drawHorizontalLine(rowIndex + 1, writer, y2); + } + if (rowBreakWithoutHeader && this.layout.hLineWhenBroken !== false) { + this.drawHorizontalLine(rowIndex, writer, y1); + } + for (let i = 0, l = xs.length; i < l; i++) { + let leftCellBorder = false; + let rightCellBorder = false; + let colIndex = xs[i].index; + + // current cell + if (colIndex < body[rowIndex].length) { + let cell = body[rowIndex][colIndex]; + leftCellBorder = cell.border ? cell.border[0] : this.layout.defaultBorder; + rightCellBorder = cell.border ? cell.border[2] : this.layout.defaultBorder; + } + + // before cell + if (colIndex > 0 && !leftCellBorder) { + let cell = body[rowIndex][colIndex - 1]; + leftCellBorder = cell.border ? cell.border[2] : this.layout.defaultBorder; + } + + // after cell + if (colIndex + 1 < body[rowIndex].length && !rightCellBorder) { + let cell = body[rowIndex][colIndex + 1]; + rightCellBorder = cell.border ? cell.border[0] : this.layout.defaultBorder; + } + if (leftCellBorder) { + this.drawVerticalLine(xs[i].x, y1 - hzLineOffset, y2 + this.bottomLineWidth, xs[i].index, writer, rowIndex, xs[i - 1] ? xs[i - 1].index : null); + } + if (i < l - 1) { + body[rowIndex][colIndex]._willBreak = body[rowIndex][colIndex]._willBreak ?? willBreak; + if (body[rowIndex][colIndex]._bottomY === undefined) { + let bottomY = this.dontBreakRows ? y2 + this.bottomLineWidth : y2 + this.bottomLineWidth / 2; + if (willBreak || this.dontBreakRows) { + bottomY = bottomY - this.rowPaddingBottom; + } + body[rowIndex][colIndex]._bottomY = bottomY - this.reservedAtBottom; + } + body[rowIndex][colIndex]._rowTopPageY = this.rowTopPageY; + if (this.dontBreakRows) { + body[rowIndex][colIndex]._rowTopPageYPadding = this.rowPaddingTop; + } + body[rowIndex][colIndex]._lastPageNumber = ys[yi].page + 1; + let fillColor = body[rowIndex][colIndex].fillColor; + let fillOpacity = body[rowIndex][colIndex].fillOpacity; + if (!fillColor) { + fillColor = typeof this.layout.fillColor === 'function' ? this.layout.fillColor(rowIndex, this.tableNode, colIndex) : this.layout.fillColor; + } + if (!isNumber(fillOpacity)) { + fillOpacity = typeof this.layout.fillOpacity === 'function' ? this.layout.fillOpacity(rowIndex, this.tableNode, colIndex) : this.layout.fillOpacity; + } + var overlayPattern = body[rowIndex][colIndex].overlayPattern; + var overlayOpacity = body[rowIndex][colIndex].overlayOpacity; + if (fillColor || overlayPattern) { + let widthLeftBorder = leftCellBorder ? this.layout.vLineWidth(colIndex, this.tableNode) : 0; + let widthRightBorder; + if ((colIndex === 0 || colIndex + 1 == body[rowIndex].length) && !rightCellBorder) { + widthRightBorder = this.layout.vLineWidth(colIndex + 1, this.tableNode); + } else if (rightCellBorder) { + widthRightBorder = this.layout.vLineWidth(colIndex + 1, this.tableNode) / 2; + } else { + widthRightBorder = 0; + } + let x1f = this.dontBreakRows ? xs[i].x + widthLeftBorder : xs[i].x + widthLeftBorder / 2; + let y1f = this.dontBreakRows ? y1 : y1 - hzLineOffset / 2; + let x2f = xs[i + 1].x + widthRightBorder; + let y2f = this.dontBreakRows ? y2 + this.bottomLineWidth : y2 + this.bottomLineWidth / 2; + var bgWidth = x2f - x1f; + var bgHeight = y2f - y1f; + if (fillColor) { + writer.addVector({ + type: 'rect', + x: x1f, + y: y1f, + w: bgWidth, + h: bgHeight, + lineWidth: 0, + color: fillColor, + fillOpacity: fillOpacity, + // mark if we are in an unbreakable block + _isFillColorFromUnbreakable: !!writer.transactionLevel + }, false, true, writer.context().backgroundLength[writer.context().page]); + } + if (overlayPattern) { + writer.addVector({ + type: 'rect', + x: x1f, + y: y1f, + w: bgWidth, + h: bgHeight, + lineWidth: 0, + color: overlayPattern, + fillOpacity: overlayOpacity + }, false, true); + } + } + } + } + } + writer.context().page = endingPage; + writer.context().y = endingY; + let row = this.tableNode.table.body[rowIndex]; + for (let i = 0, l = row.length; i < l; i++) { + if (row[i].rowSpan) { + this.rowSpanData[i].rowSpan = row[i].rowSpan; + + // fix colSpans + if (row[i].colSpan && row[i].colSpan > 1) { + for (let j = 1; j < row[i].rowSpan; j++) { + this.tableNode.table.body[rowIndex + j][i]._colSpan = row[i].colSpan; + } + } + + // fix rowSpans + if (row[i].rowSpan && row[i].rowSpan > 1) { + for (let j = 1; j < row[i].rowSpan; j++) { + this.tableNode.table.body[rowIndex + j][i]._rowSpanCurrentOffset = j; + } + } + } + if (this.rowSpanData[i].rowSpan > 0) { + this.rowSpanData[i].rowSpan--; + } + } + this.drawHorizontalLine(rowIndex + 1, writer); + if (this.headerRows && rowIndex === this.headerRows - 1) { + this.headerRepeatable = writer.currentBlockToRepeatable(); + } + const shouldCommitCurrentRowUnbreakable = this.dontBreakRows && (rowIndex === 0 || this._isCurrentRowUnbreakable); + if (shouldCommitCurrentRowUnbreakable) { + const pageChangedCallback = () => { + if (rowIndex > 0 && !this.headerRows && this.layout.hLineWhenBroken !== false) { + // Draw the top border of the row after a page break + this.drawHorizontalLine(rowIndex, writer); + } + }; + writer.addListener('pageChanged', pageChangedCallback); + writer.commitUnbreakableBlock(); + writer.removeListener('pageChanged', pageChangedCallback); + } + this._isCurrentRowUnbreakable = false; + if (this.headerRepeatable && (rowIndex === this.rowsWithoutPageBreak - 1 || rowIndex === this.tableNode.table.body.length - 1)) { + writer.commitUnbreakableBlock(); + writer.pushToRepeatables(this.headerRepeatable); + this.cleanUpRepeatables = true; + this.headerRepeatable = null; + } + } +} +/* harmony default export */ const src_TableProcessor = (TableProcessor); +;// ./src/Line.js +class Line { + /** + * @param {number} maxWidth Maximum width this line can have + */ + constructor(maxWidth) { + this.maxWidth = maxWidth; + this.leadingCut = 0; + this.trailingCut = 0; + this.inlineWidths = 0; + this.inlines = []; + } + + /** + * @param {object} inline + */ + addInline(inline) { + if (this.inlines.length === 0) { + this.leadingCut = inline.leadingCut || 0; + } + this.trailingCut = inline.trailingCut || 0; + inline.x = this.inlineWidths - this.leadingCut; + this.inlines.push(inline); + this.inlineWidths += inline.width; + if (inline.lineEnd) { + this.newLineForced = true; + } + } + + /** + * @returns {number} + */ + getHeight() { + let max = 0; + this.inlines.forEach(item => { + max = Math.max(max, item.height || 0); + }); + return max; + } + + /** + * @returns {number} + */ + getAscenderHeight() { + let y = 0; + this.inlines.forEach(inline => { + y = Math.max(y, inline.font.ascender / 1000 * inline.fontSize); + }); + return y; + } + + /** + * @returns {number} + */ + getWidth() { + return this.inlineWidths - this.leadingCut - this.trailingCut; + } + + /** + * @returns {number} + */ + getAvailableWidth() { + return this.maxWidth - this.getWidth(); + } + + /** + * @param {object} inline + * @param {Array} nextInlines + * @returns {boolean} + */ + hasEnoughSpaceForInline(inline, nextInlines) { + if (nextInlines === void 0) { + nextInlines = []; + } + if (this.inlines.length === 0) { + return true; + } + if (this.newLineForced) { + return false; + } + let inlineWidth = inline.width; + let inlineTrailingCut = inline.trailingCut || 0; + if (inline.noNewLine) { + for (let i = 0, l = nextInlines.length; i < l; i++) { + let nextInline = nextInlines[i]; + inlineWidth += nextInline.width; + inlineTrailingCut += nextInline.trailingCut || 0; + if (!nextInline.noNewLine) { + break; + } + } + } + return this.inlineWidths + inlineWidth - this.leadingCut - inlineTrailingCut <= this.maxWidth; + } + clone() { + let result = new Line(this.maxWidth); + for (let key in this) { + if (this.hasOwnProperty(key)) { + result[key] = this[key]; + } + } + return result; + } +} +/* harmony default export */ const src_Line = (Line); +;// ./src/LayoutBuilder.js + + + + + + + + + + + + +function addAll(target, otherArray) { + otherArray.forEach(item => { + target.push(item); + }); +} + +/** + * Layout engine which turns document-definition-object into a set of pages, lines, inlines + * and vectors ready to be rendered into a PDF + */ +class LayoutBuilder { + /** + * @param {object} pageSize - an object defining page width and height + * @param {object} pageMargins - an object defining top, left, right and bottom margins + * @param {object} svgMeasure + */ + constructor(pageSize, pageMargins, svgMeasure) { + this.pageSize = pageSize; + this.pageMargins = pageMargins; + this.svgMeasure = svgMeasure; + this.tableLayouts = {}; + this.nestedLevel = 0; + this.verticalAlignmentItemStack = []; + } + registerTableLayouts(tableLayouts) { + this.tableLayouts = pack(this.tableLayouts, tableLayouts); + } + + /** + * Executes layout engine on document-definition-object and creates an array of pages + * containing positioned Blocks, Lines and inlines + * + * @param {object} docStructure document-definition-object + * @param {object} pdfDocument pdfkit document + * @param {object} styleDictionary dictionary with style definitions + * @param {object} defaultStyle default style definition + * @param {object} background + * @param {object} header + * @param {object} footer + * @param {object} watermark + * @param {object} pageBreakBeforeFct + * @returns {Array} an array of pages + */ + layoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark, pageBreakBeforeFct) { + function addPageBreaksIfNecessary(linearNodeList, pages) { + if (typeof pageBreakBeforeFct !== 'function') { + return false; + } + const hasRenderableContent = node => { + if (!node || node.positions.length === 0) { + return false; + } + if (node.text === '' && !node.listMarker) { + return false; + } + return true; + }; + linearNodeList = linearNodeList.filter(hasRenderableContent); + linearNodeList.forEach(node => { + let nodeInfo = {}; + ['id', 'text', 'ul', 'ol', 'table', 'image', 'qr', 'canvas', 'svg', 'columns', 'headlineLevel', 'style', 'pageBreak', 'pageOrientation', 'width', 'height'].forEach(key => { + if (node[key] !== undefined) { + nodeInfo[key] = node[key]; + } + }); + nodeInfo.startPosition = node.positions[0]; + nodeInfo.pageNumbers = Array.from(new Set(node.positions.map(node => node.pageNumber))); + nodeInfo.pages = pages.length; + nodeInfo.stack = Array.isArray(node.stack); + node.nodeInfo = nodeInfo; + }); + for (let index = 0; index < linearNodeList.length; index++) { + let node = linearNodeList[index]; + if (node.pageBreak !== 'before' && !node.pageBreakCalculated) { + node.pageBreakCalculated = true; + let pageNumber = node.nodeInfo.pageNumbers[0]; + if (pageBreakBeforeFct(node.nodeInfo, { + getFollowingNodesOnPage: () => { + let followingNodesOnPage = []; + for (let ii = index + 1, l = linearNodeList.length; ii < l; ii++) { + if (linearNodeList[ii].nodeInfo.pageNumbers.indexOf(pageNumber) > -1) { + followingNodesOnPage.push(linearNodeList[ii].nodeInfo); + } + } + return followingNodesOnPage; + }, + getNodesOnNextPage: () => { + let nodesOnNextPage = []; + for (let ii = index + 1, l = linearNodeList.length; ii < l; ii++) { + if (linearNodeList[ii].nodeInfo.pageNumbers.indexOf(pageNumber + 1) > -1) { + nodesOnNextPage.push(linearNodeList[ii].nodeInfo); + } + } + return nodesOnNextPage; + }, + getPreviousNodesOnPage: () => { + let previousNodesOnPage = []; + for (let ii = 0; ii < index; ii++) { + if (linearNodeList[ii].nodeInfo.pageNumbers.indexOf(pageNumber) > -1) { + previousNodesOnPage.push(linearNodeList[ii].nodeInfo); + } + } + return previousNodesOnPage; + } + })) { + node.pageBreak = 'before'; + return true; + } + } + } + return false; + } + this.docPreprocessor = new src_DocPreprocessor(); + this.docMeasure = new src_DocMeasure(pdfDocument, styleDictionary, defaultStyle, this.svgMeasure, this.tableLayouts); + function resetXYs(result) { + result.linearNodeList.forEach(node => { + node.resetXY(); + }); + } + let result = this.tryLayoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark); + while (addPageBreaksIfNecessary(result.linearNodeList, result.pages)) { + resetXYs(result); + result = this.tryLayoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark); + } + return result.pages; + } + tryLayoutDocument(docStructure, pdfDocument, styleDictionary, defaultStyle, background, header, footer, watermark) { + const isNecessaryAddFirstPage = docStructure => { + if (docStructure.stack && docStructure.stack.length > 0 && docStructure.stack[0].section) { + return false; + } else if (docStructure.section) { + return false; + } + return true; + }; + this.linearNodeList = []; + docStructure = this.docPreprocessor.preprocessDocument(docStructure); + docStructure = this.docMeasure.measureDocument(docStructure); + this.writer = new src_PageElementWriter(new src_DocumentContext()); + this.writer.context().addListener('pageAdded', page => { + let backgroundGetter = background; + if (page.customProperties['background'] || page.customProperties['background'] === null) { + backgroundGetter = page.customProperties['background']; + } + this.addBackground(backgroundGetter); + }); + if (isNecessaryAddFirstPage(docStructure)) { + this.writer.addPage(this.pageSize, null, this.pageMargins); + } + this.processNode(docStructure); + this.addHeadersAndFooters(header, footer); + this.addWatermark(watermark, pdfDocument, defaultStyle); + return { + pages: this.writer.context().pages, + linearNodeList: this.linearNodeList + }; + } + addBackground(background) { + let backgroundGetter = typeof background === 'function' ? background : () => background; + let context = this.writer.context(); + let pageSize = context.getCurrentPage().pageSize; + let pageBackground = backgroundGetter(context.page + 1, pageSize); + if (pageBackground) { + this.writer.beginUnbreakableBlock(pageSize.width, pageSize.height); + pageBackground = this.docPreprocessor.preprocessBlock(pageBackground); + this.processNode(this.docMeasure.measureBlock(pageBackground)); + this.writer.commitUnbreakableBlock(0, 0); + context.backgroundLength[context.page] += pageBackground.positions.length; + } + } + addDynamicRepeatable(nodeGetter, sizeFunction, customPropertyName) { + let pages = this.writer.context().pages; + for (let pageIndex = 0, l = pages.length; pageIndex < l; pageIndex++) { + this.writer.context().page = pageIndex; + let customProperties = this.writer.context().getCurrentPage().customProperties; + let pageNodeGetter = nodeGetter; + if (customProperties[customPropertyName] || customProperties[customPropertyName] === null) { + pageNodeGetter = customProperties[customPropertyName]; + } + if (typeof pageNodeGetter === 'undefined' || pageNodeGetter === null) { + continue; + } + let node = pageNodeGetter(pageIndex + 1, l, this.writer.context().pages[pageIndex].pageSize); + if (node) { + let sizes = sizeFunction(this.writer.context().getCurrentPage().pageSize, this.writer.context().getCurrentPage().pageMargins); + this.writer.beginUnbreakableBlock(sizes.width, sizes.height); + node = this.docPreprocessor.preprocessBlock(node); + this.processNode(this.docMeasure.measureBlock(node)); + this.writer.commitUnbreakableBlock(sizes.x, sizes.y); + } + } + } + addHeadersAndFooters(header, footer) { + const headerSizeFct = (pageSize, pageMargins) => ({ + x: 0, + y: 0, + width: pageSize.width, + height: pageMargins.top + }); + const footerSizeFct = (pageSize, pageMargins) => ({ + x: 0, + y: pageSize.height - pageMargins.bottom, + width: pageSize.width, + height: pageMargins.bottom + }); + this.addDynamicRepeatable(header, headerSizeFct, 'header'); + this.addDynamicRepeatable(footer, footerSizeFct, 'footer'); + } + addWatermark(watermark, pdfDocument, defaultStyle) { + let pages = this.writer.context().pages; + for (let i = 0, l = pages.length; i < l; i++) { + let pageWatermark = watermark; + if (pages[i].customProperties['watermark'] || pages[i].customProperties['watermark'] === null) { + pageWatermark = pages[i].customProperties['watermark']; + } + if (pageWatermark === undefined || pageWatermark === null) { + continue; + } + if (isString(pageWatermark)) { + pageWatermark = { + 'text': pageWatermark + }; + } + if (!pageWatermark.text) { + // empty watermark text + continue; + } + pages[i].watermark = getWatermarkObject({ + ...pageWatermark + }, pages[i].pageSize, pdfDocument, defaultStyle); + } + function getWatermarkObject(watermark, pageSize, pdfDocument, defaultStyle) { + watermark.font = watermark.font || defaultStyle.font || 'Roboto'; + watermark.fontSize = watermark.fontSize || 'auto'; + watermark.color = watermark.color || 'black'; + watermark.opacity = isNumber(watermark.opacity) ? watermark.opacity : 0.6; + watermark.bold = watermark.bold || false; + watermark.italics = watermark.italics || false; + watermark.angle = isValue(watermark.angle) ? watermark.angle : null; + if (watermark.angle === null) { + watermark.angle = Math.atan2(pageSize.height, pageSize.width) * -180 / Math.PI; + } + if (watermark.fontSize === 'auto') { + watermark.fontSize = getWatermarkFontSize(pageSize, watermark, pdfDocument); + } + let watermarkObject = { + text: watermark.text, + font: pdfDocument.provideFont(watermark.font, watermark.bold, watermark.italics), + fontSize: watermark.fontSize, + color: watermark.color, + opacity: watermark.opacity, + angle: watermark.angle + }; + watermarkObject._size = getWatermarkSize(watermark, pdfDocument); + return watermarkObject; + } + function getWatermarkSize(watermark, pdfDocument) { + let textInlines = new src_TextInlines(pdfDocument); + let styleContextStack = new src_StyleContextStack(null, { + font: watermark.font, + bold: watermark.bold, + italics: watermark.italics + }); + styleContextStack.push({ + fontSize: watermark.fontSize + }); + let size = textInlines.sizeOfText(watermark.text, styleContextStack); + let rotatedSize = textInlines.sizeOfRotatedText(watermark.text, watermark.angle, styleContextStack); + return { + size: size, + rotatedSize: rotatedSize + }; + } + function getWatermarkFontSize(pageSize, watermark, pdfDocument) { + let textInlines = new src_TextInlines(pdfDocument); + let styleContextStack = new src_StyleContextStack(null, { + font: watermark.font, + bold: watermark.bold, + italics: watermark.italics + }); + let rotatedSize; + + /** + * Binary search the best font size. + * Initial bounds [0, 1000] + * Break when range < 1 + */ + let a = 0; + let b = 1000; + let c = (a + b) / 2; + while (Math.abs(a - b) > 1) { + styleContextStack.push({ + fontSize: c + }); + rotatedSize = textInlines.sizeOfRotatedText(watermark.text, watermark.angle, styleContextStack); + if (rotatedSize.width > pageSize.width) { + b = c; + c = (a + b) / 2; + } else if (rotatedSize.width < pageSize.width) { + if (rotatedSize.height > pageSize.height) { + b = c; + c = (a + b) / 2; + } else { + a = c; + c = (a + b) / 2; + } + } + styleContextStack.pop(); + } + /* + End binary search + */ + return c; + } + } + processNode(node, isVerticalAlignmentAllowed) { + if (isVerticalAlignmentAllowed === void 0) { + isVerticalAlignmentAllowed = false; + } + const applyMargins = callback => { + let margin = node._margin; + if (node.pageBreak === 'before') { + this.writer.moveToNextPage(node.pageOrientation); + } else if (node.pageBreak === 'beforeOdd') { + this.writer.moveToNextPage(node.pageOrientation); + if ((this.writer.context().page + 1) % 2 === 1) { + this.writer.moveToNextPage(node.pageOrientation); + } + } else if (node.pageBreak === 'beforeEven') { + this.writer.moveToNextPage(node.pageOrientation); + if ((this.writer.context().page + 1) % 2 === 0) { + this.writer.moveToNextPage(node.pageOrientation); + } + } + const isDetachedBlock = node.relativePosition || node.absolutePosition; + + // Detached nodes have no margins, their position is only determined by 'x' and 'y' + if (margin && !isDetachedBlock) { + const availableHeight = this.writer.context().availableHeight; + // If top margin is bigger than available space, move to next page + // Necessary for nodes inside tables + if (availableHeight - margin[1] < 0) { + // Consume the whole available space + this.writer.context().moveDown(availableHeight); + if (this.writer.context().inSnakingColumns() && !this.writer.context().isInNestedNonSnakingGroup()) { + this.snakingAwarePageBreak(node.pageOrientation); + } else { + this.writer.moveToNextPage(node.pageOrientation); + } + /** + * TODO - Something to consider: + * Right now the node starts at the top of next page (after header) + * Another option would be to apply just the top margin that has not been consumed in the page before + * It would something like: this.write.context().moveDown(margin[1] - availableHeight) + */ + } else { + this.writer.context().moveDown(margin[1]); + } + // Apply lateral margins + this.writer.context().addMargin(margin[0], margin[2]); + } + callback(); + + // Detached nodes have no margins, their position is only determined by 'x' and 'y' + if (margin && !isDetachedBlock) { + const availableHeight = this.writer.context().availableHeight; + // If bottom margin is bigger than available space, move to next page + // Necessary for nodes inside tables + if (availableHeight - margin[3] < 0) { + this.writer.context().moveDown(availableHeight); + if (this.writer.context().inSnakingColumns() && !this.writer.context().isInNestedNonSnakingGroup()) { + this.snakingAwarePageBreak(node.pageOrientation); + } else { + this.writer.moveToNextPage(node.pageOrientation); + } + /** + * TODO - Something to consider: + * Right now next node starts at the top of next page (after header) + * Another option would be to apply the bottom margin that has not been consumed in the next page? + * It would something like: this.write.context().moveDown(margin[3] - availableHeight) + */ + } else { + this.writer.context().moveDown(margin[3]); + } + // Apply lateral margins + this.writer.context().addMargin(-margin[0], -margin[2]); + } + if (node.pageBreak === 'after') { + this.writer.moveToNextPage(node.pageOrientation); + } else if (node.pageBreak === 'afterOdd') { + this.writer.moveToNextPage(node.pageOrientation); + if ((this.writer.context().page + 1) % 2 === 1) { + this.writer.moveToNextPage(node.pageOrientation); + } + } else if (node.pageBreak === 'afterEven') { + this.writer.moveToNextPage(node.pageOrientation); + if ((this.writer.context().page + 1) % 2 === 0) { + this.writer.moveToNextPage(node.pageOrientation); + } + } + }; + this.linearNodeList.push(node); + decorateNode(node); + if (this.writer.context().getCurrentPage() !== null) { + var prevTop = this.writer.context().getCurrentPosition().top; + } + applyMargins(() => { + let verticalAlignment = node.verticalAlignment; + if (isVerticalAlignmentAllowed && verticalAlignment) { + var verticalAlignmentBegin = this.writer.beginVerticalAlignment(verticalAlignment); + } + let unbreakable = node.unbreakable; + if (unbreakable) { + this.writer.beginUnbreakableBlock(); + } + let absPosition = node.absolutePosition; + if (absPosition) { + this.writer.context().beginDetachedBlock(); + this.writer.context().moveTo(absPosition.x || 0, absPosition.y || 0); + } + let relPosition = node.relativePosition; + if (relPosition) { + this.writer.context().beginDetachedBlock(); + this.writer.context().moveToRelative(relPosition.x || 0, relPosition.y || 0); + } + if (node.stack) { + this.processVerticalContainer(node); + } else if (node.section) { + this.processSection(node); + } else if (node.columns) { + this.processColumns(node); + } else if (node.ul) { + this.processList(false, node); + } else if (node.ol) { + this.processList(true, node); + } else if (node.table) { + this.processTable(node); + } else if (node.text !== undefined) { + this.processLeaf(node); + } else if (node.toc) { + this.processToc(node); + } else if (node.image) { + this.processImage(node); + } else if (node.svg) { + this.processSVG(node); + } else if (node.canvas) { + this.processCanvas(node); + } else if (node.qr) { + this.processQr(node); + } else if (node.attachment) { + this.processAttachment(node); + } else if (!node._span) { + throw new Error(`Unrecognized document structure: ${stringifyNode(node)}`); + } + if (absPosition || relPosition) { + this.writer.context().endDetachedBlock(); + } + if (unbreakable) { + this.writer.commitUnbreakableBlock(); + } + if (isVerticalAlignmentAllowed && verticalAlignment) { + this.verticalAlignmentItemStack.push({ + begin: verticalAlignmentBegin, + end: this.writer.endVerticalAlignment(verticalAlignment) + }); + } + }); + if (prevTop !== undefined) { + // TODO: for vertical alignment and does not work (at least) when page break in node + node.__height = this.writer.context().getCurrentPosition().top - prevTop; + } + } + + /** + * Helper for page breaks that respects snaking column context. + * When in snaking columns, first tries moving to next column. + * If no columns available, moves to next page and resets x to left margin. + * @param {string} pageOrientation - Optional page orientation for the new page + */ + snakingAwarePageBreak(pageOrientation) { + let ctx = this.writer.context(); + let snakingSnapshot = ctx.getSnakingSnapshot(); + if (!snakingSnapshot) { + return; + } + + // Try flowing to next column first + if (this.writer.canMoveToNextColumn()) { + this.writer.moveToNextColumn(); + return; + } + + // No more columns available, move to new page + this.writer.moveToNextPage(pageOrientation); + + // Reset snaking column state for the new page + // Save lastColumnWidth before reset — if we're inside a nested + // column group (e.g. product/price row), the reset would overwrite + // it with the snaking column width, corrupting inner column layout. + let savedLastColumnWidth = ctx.lastColumnWidth; + ctx.resetSnakingColumnsForNewPage(); + ctx.lastColumnWidth = savedLastColumnWidth; + } + + // vertical container + processVerticalContainer(node) { + node.stack.forEach(item => { + this.processNode(item); + addAll(node.positions, item.positions); + + //TODO: paragraph gap + }, this); + } + + // section + processSection(sectionNode) { + // TODO: properties + + let page = this.writer.context().getCurrentPage(); + if (!page || page && page.items.length) { + // move to new empty page + // page definition inherit from current page + if (sectionNode.pageSize === 'inherit') { + sectionNode.pageSize = page ? { + width: page.pageSize.width, + height: page.pageSize.height + } : undefined; + } + if (sectionNode.pageOrientation === 'inherit') { + sectionNode.pageOrientation = page ? page.pageSize.orientation : undefined; + } + if (sectionNode.pageMargins === 'inherit') { + sectionNode.pageMargins = page ? page.pageMargins : undefined; + } + if (sectionNode.header === 'inherit') { + sectionNode.header = page ? page.customProperties.header : undefined; + } + if (sectionNode.footer === 'inherit') { + sectionNode.footer = page ? page.customProperties.footer : undefined; + } + if (sectionNode.background === 'inherit') { + sectionNode.background = page ? page.customProperties.background : undefined; + } + if (sectionNode.watermark === 'inherit') { + sectionNode.watermark = page ? page.customProperties.watermark : undefined; + } + if (sectionNode.header && typeof sectionNode.header !== 'function' && sectionNode.header !== null) { + sectionNode.header = convertToDynamicContent(sectionNode.header); + } + if (sectionNode.footer && typeof sectionNode.footer !== 'function' && sectionNode.footer !== null) { + sectionNode.footer = convertToDynamicContent(sectionNode.footer); + } + let customProperties = {}; + if (typeof sectionNode.header !== 'undefined') { + customProperties.header = sectionNode.header; + } + if (typeof sectionNode.footer !== 'undefined') { + customProperties.footer = sectionNode.footer; + } + if (typeof sectionNode.background !== 'undefined') { + customProperties.background = sectionNode.background; + } + if (typeof sectionNode.watermark !== 'undefined') { + customProperties.watermark = sectionNode.watermark; + } + this.writer.addPage(sectionNode.pageSize || this.pageSize, sectionNode.pageOrientation, sectionNode.pageMargins || this.pageMargins, customProperties); + } + this.processNode(sectionNode.section); + } + + // columns + processColumns(columnNode) { + this.nestedLevel++; + let columns = columnNode.columns; + let availableWidth = this.writer.context().availableWidth; + let gaps = gapArray(columnNode._gap); + if (gaps) { + availableWidth -= (gaps.length - 1) * columnNode._gap; + } + columnCalculator.buildColumnWidths(columns, availableWidth); + let result = this.processRow({ + marginX: columnNode._margin ? [columnNode._margin[0], columnNode._margin[2]] : [0, 0], + cells: columns, + widths: columns, + gaps, + snakingColumns: columnNode.snakingColumns + }); + addAll(columnNode.positions, result.positions); + this.nestedLevel--; + if (this.nestedLevel === 0) { + this.writer.context().resetMarginXTopParent(); + } + function gapArray(gap) { + if (!gap) { + return null; + } + let gaps = []; + gaps.push(0); + for (let i = columns.length - 1; i > 0; i--) { + gaps.push(gap); + } + return gaps; + } + } + + /** + * Searches for a cell in the same row that starts a rowspan and is positioned immediately before the current cell. + * Alternatively, it finds a cell where the colspan initiating the rowspan extends to the cell just before the current one. + * + * @param {Array} arr - An array representing cells in a row. + * @param {number} i - The index of the current cell to search backward from. + * @returns {object|null} The starting cell of the rowspan if found; otherwise, `null`. + */ + _findStartingRowSpanCell(arr, i) { + let requiredColspan = 1; + for (let index = i - 1; index >= 0; index--) { + if (!arr[index]._span) { + if (arr[index].rowSpan > 1 && (arr[index].colSpan || 1) === requiredColspan) { + return arr[index]; + } else { + return null; + } + } + requiredColspan++; + } + return null; + } + + /** + * Retrieves a page break description for a specified page from a list of page breaks. + * + * @param {Array} pageBreaks - An array of page break descriptions, each containing `prevPage` properties. + * @param {number} page - The page number to find the associated page break for. + * @returns {object|undefined} The page break description object for the specified page if found; otherwise, `undefined`. + */ + _getPageBreak(pageBreaks, page) { + return pageBreaks.find(desc => desc.prevPage === page); + } + _getPageBreakListBySpan(tableNode, page, rowIndex) { + if (!tableNode || !tableNode._breaksBySpan) { + return null; + } + const breaksList = tableNode._breaksBySpan.filter(desc => desc.prevPage === page && rowIndex <= desc.rowIndexOfSpanEnd); + let y = Number.MAX_VALUE, + prevY = Number.MIN_VALUE; + breaksList.forEach(b => { + prevY = Math.max(b.prevY, prevY); + y = Math.min(b.y, y); + }); + return { + prevPage: page, + prevY: prevY, + y: y + }; + } + _findSameRowPageBreakByRowSpanData(breaksBySpan, page, rowIndex) { + if (!breaksBySpan) { + return null; + } + return breaksBySpan.find(desc => desc.prevPage === page && rowIndex === desc.rowIndexOfSpanEnd); + } + _updatePageBreaksData(pageBreaks, tableNode, rowIndex) { + Object.keys(tableNode._bottomByPage).forEach(p => { + const page = Number(p); + const pageBreak = this._getPageBreak(pageBreaks, page); + if (pageBreak) { + pageBreak.prevY = Math.max(pageBreak.prevY, tableNode._bottomByPage[page]); + } + if (tableNode._breaksBySpan && tableNode._breaksBySpan.length > 0) { + const breaksBySpanList = tableNode._breaksBySpan.filter(pb => pb.prevPage === page && rowIndex <= pb.rowIndexOfSpanEnd); + if (breaksBySpanList && breaksBySpanList.length > 0) { + breaksBySpanList.forEach(b => { + b.prevY = Math.max(b.prevY, tableNode._bottomByPage[page]); + }); + } + } + }); + } + + /** + * Resolves the Y-coordinates for a target object by comparing two break points. + * + * @param {object} break1 - The first break point with `prevY` and `y` properties. + * @param {object} break2 - The second break point with `prevY` and `y` properties. + * @param {object} target - The target object to be updated with resolved Y-coordinates. + * @property {number} target.prevY - Updated to the maximum `prevY` value between `break1` and `break2`. + * @property {number} target.y - Updated to the minimum `y` value between `break1` and `break2`. + */ + _resolveBreakY(break1, break2, target) { + target.prevY = Math.max(break1.prevY, break2.prevY); + target.y = Math.min(break1.y, break2.y); + } + _storePageBreakData(data, startsRowSpan, pageBreaks, tableNode) { + if (!startsRowSpan) { + let pageDesc = this._getPageBreak(pageBreaks, data.prevPage); + let pageDescBySpan = this._getPageBreakListBySpan(tableNode, data.prevPage, data.rowIndex); + if (!pageDesc) { + pageDesc = { + ...data + }; + pageBreaks.push(pageDesc); + } + if (pageDescBySpan) { + this._resolveBreakY(pageDesc, pageDescBySpan, pageDesc); + } + this._resolveBreakY(pageDesc, data, pageDesc); + } else { + const breaksBySpan = tableNode && tableNode._breaksBySpan || null; + let pageDescBySpan = this._findSameRowPageBreakByRowSpanData(breaksBySpan, data.prevPage, data.rowIndex); + if (!pageDescBySpan) { + pageDescBySpan = { + ...data, + rowIndexOfSpanEnd: data.rowIndex + data.rowSpan - 1 + }; + if (!tableNode._breaksBySpan) { + tableNode._breaksBySpan = []; + } + tableNode._breaksBySpan.push(pageDescBySpan); + } + pageDescBySpan.prevY = Math.max(pageDescBySpan.prevY, data.prevY); + pageDescBySpan.y = Math.min(pageDescBySpan.y, data.y); + let pageDesc = this._getPageBreak(pageBreaks, data.prevPage); + if (pageDesc) { + this._resolveBreakY(pageDesc, pageDescBySpan, pageDesc); + } + } + } + /** + * Calculates the left offset for a column based on the specified gap values. + * + * @param {number} i - The index of the column for which the offset is being calculated. + * @param {Array} gaps - An array of gap values for each column. + * @returns {number} The left offset for the column. Returns `gaps[i]` if it exists, otherwise `0`. + */ + _colLeftOffset(i, gaps) { + if (gaps && gaps.length > i) { + return gaps[i]; + } + return 0; + } + + /** + * Retrieves the ending cell for a row span in case it exists in a specified table column. + * + * @param {Array>} tableBody - The table body, represented as a 2D array of cell objects. + * @param {number} rowIndex - The index of the starting row for the row span. + * @param {object} column - The column object containing row span information. + * @param {number} columnIndex - The index of the column within the row. + * @returns {object|null} The cell at the end of the row span if it exists; otherwise, `null`. + * @throws {Error} If the row span extends beyond the total row count. + */ + _getRowSpanEndingCell(tableBody, rowIndex, column, columnIndex) { + if (column.rowSpan && column.rowSpan > 1) { + let endingRow = rowIndex + column.rowSpan - 1; + if (endingRow >= tableBody.length) { + throw new Error(`Row span for column ${columnIndex} (with indexes starting from 0) exceeded row count`); + } + return tableBody[endingRow][columnIndex]; + } + return null; + } + processRow(_ref) { + let _ref$marginX = _ref.marginX, + marginX = _ref$marginX === void 0 ? [0, 0] : _ref$marginX, + _ref$dontBreakRows = _ref.dontBreakRows, + dontBreakRows = _ref$dontBreakRows === void 0 ? false : _ref$dontBreakRows, + _ref$rowsWithoutPageB = _ref.rowsWithoutPageBreak, + rowsWithoutPageBreak = _ref$rowsWithoutPageB === void 0 ? 0 : _ref$rowsWithoutPageB, + cells = _ref.cells, + widths = _ref.widths, + gaps = _ref.gaps, + tableNode = _ref.tableNode, + tableBody = _ref.tableBody, + rowIndex = _ref.rowIndex, + height = _ref.height, + _ref$snakingColumns = _ref.snakingColumns, + snakingColumns = _ref$snakingColumns === void 0 ? false : _ref$snakingColumns; + const isUnbreakableRow = dontBreakRows || rowIndex <= rowsWithoutPageBreak - 1; + let pageBreaks = []; + let pageBreaksByRowSpan = []; + let positions = []; + let willBreakByHeight = false; + let verticalAlignmentCells = {}; + widths = widths || cells; + + // Check if row should break by height + if (!isUnbreakableRow && height > this.writer.context().availableHeight) { + willBreakByHeight = true; + } + + // Use the marginX if we are in a top level table/column (not nested) + const marginXParent = this.nestedLevel === 1 ? marginX : null; + const _bottomByPage = tableNode ? tableNode._bottomByPage : null; + // Pass column gap and widths to context snapshot for snaking columns + // to advance correctly and reset to first-column width on new pages. + const columnGapForGroup = gaps && gaps.length > 1 ? gaps[1] : 0; + const columnWidthsForContext = widths.map(w => w._calcWidth); + this.writer.context().beginColumnGroup(marginXParent, _bottomByPage, snakingColumns, columnGapForGroup, columnWidthsForContext); + + // IMPORTANT: We iterate ALL columns even when snakingColumns is enabled. + // This is intentional — beginColumn() must be called for each column to set up + // proper geometry (widths, offsets) and rowspan/colspan tracking. The + // completeColumnGroup() call at the end depends on this bookkeeping to compute + // heights correctly. Content processing is skipped for columns > 0 via + // skipForSnaking below, but the column structure must still be established. + for (let i = 0, l = cells.length; i < l; i++) { + let cell = cells[i]; + let cellIndexBegin = i; + + // Page change handler + const storePageBreakClosure = data => { + const startsRowSpan = cell.rowSpan && cell.rowSpan > 1; + if (startsRowSpan) { + data.rowSpan = cell.rowSpan; + } + data.rowIndex = rowIndex; + this._storePageBreakData(data, startsRowSpan, pageBreaks, tableNode); + }; + this.writer.addListener('pageChanged', storePageBreakClosure); + let width = widths[i]._calcWidth; + let leftOffset = this._colLeftOffset(i, gaps); + // Check if exists and retrieve the cell that started the rowspan in case we are in the cell just after + let startingSpanCell = this._findStartingRowSpanCell(cells, i); + if (cell.colSpan && cell.colSpan > 1) { + for (let j = 1; j < cell.colSpan; j++) { + width += widths[++i]._calcWidth + gaps[i]; + } + } + + // if rowspan starts in this cell, we retrieve the last cell affected by the rowspan + const rowSpanRightEndingCell = this._getRowSpanEndingCell(tableBody, rowIndex, cell, i); + const rowSpanLeftEndingCell = this._getRowSpanEndingCell(tableBody, rowIndex, cell, cellIndexBegin); + if (rowSpanRightEndingCell) { + // We store a reference of the ending cell in the first cell of the rowspan + cell._endingCell = rowSpanRightEndingCell; + cell._endingCell._startingRowSpanY = cell._startingRowSpanY; + cell._endingCell._startingRowSpanPage = cell._startingRowSpanPage; + } + if (rowSpanLeftEndingCell) { + // We store a reference of the left ending cell in the first cell of the rowspan + cell._leftEndingCell = rowSpanLeftEndingCell; + cell._leftEndingCell._startingRowSpanY = cell._startingRowSpanY; + cell._leftEndingCell._startingRowSpanPage = cell._startingRowSpanPage; + } + + // If we are after a cell that started a rowspan + let endOfRowSpanCell = null; + if (startingSpanCell && startingSpanCell._endingCell) { + // Reference to the last cell of the rowspan + endOfRowSpanCell = startingSpanCell._endingCell; + // Store if we are in an unbreakable block when we save the context and the originalX + if (this.writer.transactionLevel > 0) { + endOfRowSpanCell._isUnbreakableContext = true; + endOfRowSpanCell._originalXOffset = this.writer.originalX; + } + } + + // We pass the endingSpanCell reference to store the context just after processing rowspan cell + this.writer.context().beginColumn(width, leftOffset, endOfRowSpanCell); + + // When snaking, only process content from the first column (i === 0). + // Content overflows into subsequent columns via moveToNextColumn(). + // We skip content processing here but NOT the beginColumn() call above — + // the column geometry setup is still needed for proper layout bookkeeping. + const skipForSnaking = snakingColumns && i > 0; + if (!cell._span && !skipForSnaking) { + this.processNode(cell, true); + this.writer.context().updateBottomByPage(); + if (cell.verticalAlignment) { + verticalAlignmentCells[cellIndexBegin] = this.verticalAlignmentItemStack.length - 1; + } + addAll(positions, cell.positions); + } else if (cell._columnEndingContext) { + let discountY = 0; + if (dontBreakRows) { + // Calculate how many points we have to discount to Y when dontBreakRows and rowSpan are combined + const ctxBeforeRowSpanLastRow = this.writer.contextStack[this.writer.contextStack.length - 1]; + const startsOnCurrentPage = typeof cell._startingRowSpanPage === 'number' && cell._startingRowSpanPage === ctxBeforeRowSpanLastRow.page; + if (startsOnCurrentPage && typeof cell._startingRowSpanY === 'number') { + discountY = ctxBeforeRowSpanLastRow.y - cell._startingRowSpanY; + } + + // Do not increase Y by applying a negative discount. + discountY = Math.max(0, discountY); + } + let originalXOffset = 0; + // If context was saved from an unbreakable block and we are not in an unbreakable block anymore + // We have to sum the originalX (X before starting unbreakable block) to X + if (cell._isUnbreakableContext && !this.writer.transactionLevel) { + originalXOffset = cell._originalXOffset; + } + // row-span ending + // Recover the context after processing the rowspanned cell + this.writer.context().markEnding(cell, originalXOffset, discountY); + } + this.writer.removeListener('pageChanged', storePageBreakClosure); + } + + // Check if last cell is part of a span + let endingSpanCell = null; + const lastColumn = cells.length > 0 ? cells[cells.length - 1] : null; + if (lastColumn) { + // Previous column cell has a rowspan + if (lastColumn._endingCell) { + endingSpanCell = lastColumn._endingCell; + // Previous column cell is part of a span + } else if (lastColumn._span === true) { + // We get the cell that started the span where we set a reference to the ending cell + const startingSpanCell = this._findStartingRowSpanCell(cells, cells.length); + if (startingSpanCell) { + // Context will be stored here (ending cell) + endingSpanCell = startingSpanCell._endingCell; + // Store if we are in an unbreakable block when we save the context and the originalX + if (this.writer.transactionLevel > 0) { + endingSpanCell._isUnbreakableContext = true; + endingSpanCell._originalXOffset = this.writer.originalX; + } + } + } + } + + // If content did not break page, check if we should break by height + if (willBreakByHeight && !isUnbreakableRow && pageBreaks.length === 0) { + this.writer.context().moveDown(this.writer.context().availableHeight); + if (snakingColumns) { + this.snakingAwarePageBreak(); + } else { + this.writer.moveToNextPage(); + } + } + const bottomByPage = this.writer.context().completeColumnGroup(height, endingSpanCell); + if (tableNode) { + tableNode._bottomByPage = bottomByPage; + // If there are page breaks in this row, update data with prevY of last cell + this._updatePageBreaksData(pageBreaks, tableNode, rowIndex); + } + let rowHeight = this.writer.context().height; + for (let i = 0, l = cells.length; i < l; i++) { + let cell = cells[i]; + if (!cell._span && cell.verticalAlignment) { + let itemBegin = this.verticalAlignmentItemStack[verticalAlignmentCells[i]].begin.item; + itemBegin.viewHeight = rowHeight; + itemBegin.nodeHeight = cell.__height; + itemBegin.cell = cell; + itemBegin.bottomY = this.writer.context().y; + itemBegin.isCellContentMultiPage = !itemBegin.cell.positions.every(item => item.pageNumber === itemBegin.cell.positions[0].pageNumber); + itemBegin.getViewHeight = function () { + if (this.cell._willBreak) { + return this.cell._bottomY - this.cell._rowTopPageY; + } + if (this.cell.rowSpan && this.cell.rowSpan > 1) { + if (dontBreakRows) { + let rowTopPageY = this.cell._leftEndingCell._startingRowSpanY + this.cell._leftEndingCell._rowTopPageYPadding; + return this.cell._leftEndingCell._rowTopPageY - rowTopPageY + this.cell._leftEndingCell._bottomY; + } else { + if (this.cell.positions[0].pageNumber !== this.cell._leftEndingCell._lastPageNumber) { + return this.bottomY - this.cell._leftEndingCell._bottomY; + } + return this.viewHeight + this.cell._leftEndingCell._bottomY - this.bottomY; + } + } + return this.viewHeight; + }; + itemBegin.getNodeHeight = function () { + return this.nodeHeight; + }; + let itemEnd = this.verticalAlignmentItemStack[verticalAlignmentCells[i]].end.item; + itemEnd.isCellContentMultiPage = itemBegin.isCellContentMultiPage; + } + } + return { + pageBreaksBySpan: pageBreaksByRowSpan, + pageBreaks: pageBreaks, + positions: positions + }; + } + + // lists + processList(orderedList, node) { + const addMarkerToFirstLeaf = line => { + // I'm not very happy with the way list processing is implemented + // (both code and algorithm should be rethinked) + if (nextMarker) { + let marker = nextMarker; + nextMarker = null; + if (marker.canvas) { + let vector = marker.canvas[0]; + offsetVector(vector, -marker._minWidth, 0); + this.writer.addVector(vector); + } else if (marker._inlines) { + let markerLine = new src_Line(this.pageSize.width); + markerLine.addInline(marker._inlines[0]); + markerLine.x = -marker._minWidth; + markerLine.y = line.getAscenderHeight() - markerLine.getAscenderHeight(); + this.writer.addLine(markerLine, true); + } + } + }; + let items = orderedList ? node.ol : node.ul; + let gapSize = node._gapSize; + this.writer.context().addMargin(gapSize.width); + let nextMarker; + this.writer.addListener('lineAdded', addMarkerToFirstLeaf); + items.forEach(item => { + nextMarker = item.listMarker; + this.processNode(item); + addAll(node.positions, item.positions); + }); + this.writer.removeListener('lineAdded', addMarkerToFirstLeaf); + this.writer.context().addMargin(-gapSize.width); + } + + // tables + processTable(tableNode) { + this.nestedLevel++; + let processor = new src_TableProcessor(tableNode); + processor.beginTable(this.writer); + let rowHeights = tableNode.table.heights; + let lastRowHeight = 0; + for (let i = 0, l = tableNode.table.body.length; i < l; i++) { + // Between table rows: check if we should move to the next snaking column. + // This must happen AFTER the previous row's endRow (borders drawn) and + // BEFORE this row's beginRow. At this point, the table row column group + // has been completed, so canMoveToNextColumn() works correctly. + if (i > 0 && this.writer.context().inSnakingColumns()) { + // Estimate minimum space for next row: use last row's height as heuristic, + // or fall back to a minimum of padding + line height + border + let minRowHeight = lastRowHeight > 0 ? lastRowHeight : processor.rowPaddingTop + 14 + processor.rowPaddingBottom + processor.bottomLineWidth + processor.topLineWidth; + if (this.writer.context().availableHeight < minRowHeight) { + this.snakingAwarePageBreak(); + + // Skip border when headerRows present (header repeat includes it) + if (processor.layout.hLineWhenBroken !== false && !processor.headerRows) { + processor.drawHorizontalLine(i, this.writer); + } + } + } + let rowYBefore = this.writer.context().y; + + // if dontBreakRows and row starts a rowspan + // we store the 'y' of the beginning of each rowSpan + if (processor.dontBreakRows) { + tableNode.table.body[i].forEach(cell => { + if (cell.rowSpan && cell.rowSpan > 1) { + cell._startingRowSpanY = this.writer.context().y; + cell._startingRowSpanPage = this.writer.context().page; + } + }); + } + processor.beginRow(i, this.writer); + let height; + if (typeof rowHeights === 'function') { + height = rowHeights(i); + } else if (Array.isArray(rowHeights)) { + height = rowHeights[i]; + } else { + height = rowHeights; + } + if (height === 'auto') { + height = undefined; + } + const pageBeforeProcessing = this.writer.context().page; + let result = this.processRow({ + marginX: tableNode._margin ? [tableNode._margin[0], tableNode._margin[2]] : [0, 0], + dontBreakRows: processor.dontBreakRows, + rowsWithoutPageBreak: processor.rowsWithoutPageBreak, + cells: tableNode.table.body[i], + widths: tableNode.table.widths, + gaps: tableNode._offsets.offsets, + tableBody: tableNode.table.body, + tableNode, + rowIndex: i, + height + }); + addAll(tableNode.positions, result.positions); + if (!result.pageBreaks || result.pageBreaks.length === 0) { + const breaksBySpan = tableNode && tableNode._breaksBySpan || null; + const breakBySpanData = this._findSameRowPageBreakByRowSpanData(breaksBySpan, pageBeforeProcessing, i); + if (breakBySpanData) { + const finalBreakBySpanData = this._getPageBreakListBySpan(tableNode, breakBySpanData.prevPage, i); + result.pageBreaks.push(finalBreakBySpanData); + } + } + processor.endRow(i, this.writer, result.pageBreaks); + + // Track the height of the completed row for the next row's estimate + let rowYAfter = this.writer.context().y; + if (this.writer.context().page === pageBeforeProcessing) { + lastRowHeight = rowYAfter - rowYBefore; + } + } + processor.endTable(this.writer); + this.nestedLevel--; + if (this.nestedLevel === 0) { + this.writer.context().resetMarginXTopParent(); + } + } + + // leafs (texts) + processLeaf(node) { + let line = this.buildNextLine(node); + if (line && (node.tocItem || node.id)) { + line._node = node; + } + let currentHeight = line ? line.getHeight() : 0; + let maxHeight = node.maxHeight || -1; + if (line) { + let nodeId = getNodeId(node); + if (nodeId) { + line.id = nodeId; + } + } + if (node.outline) { + line._outline = { + id: node.id, + parentId: node.outlineParentId, + text: node.outlineText || node.text, + expanded: node.outlineExpanded || false + }; + } else if (Array.isArray(node.text)) { + for (let i = 0, l = node.text.length; i < l; i++) { + let item = node.text[i]; + if (item.outline) { + line._outline = { + id: item.id, + parentId: item.outlineParentId, + text: item.outlineText || item.text, + expanded: item.outlineExpanded || false + }; + } + } + } + if (node._tocItemRef) { + line._pageNodeRef = node._tocItemRef; + } + if (node._pageRef) { + line._pageNodeRef = node._pageRef._nodeRef; + } + if (line && line.inlines && Array.isArray(line.inlines)) { + for (let i = 0, l = line.inlines.length; i < l; i++) { + if (line.inlines[i]._tocItemRef) { + line.inlines[i]._pageNodeRef = line.inlines[i]._tocItemRef; + } + if (line.inlines[i]._pageRef) { + line.inlines[i]._pageNodeRef = line.inlines[i]._pageRef._nodeRef; + } + } + } + while (line && (maxHeight === -1 || currentHeight < maxHeight)) { + // Check if line fits vertically in current context + if (line.getHeight() > this.writer.context().availableHeight && this.writer.context().y > this.writer.context().pageMargins.top) { + // Line doesn't fit, forced move to next page/column + // Only do snaking-specific break if we're in snaking columns AND NOT inside + // a nested non-snaking group (like a table row). Table cells should use + // standard page breaks — column breaks happen between table rows instead. + if (this.writer.context().inSnakingColumns() && !this.writer.context().isInNestedNonSnakingGroup()) { + this.snakingAwarePageBreak(node.pageOrientation); + + // Always reflow text after a snaking break (column or page). + // This ensures text adapts to the new column width, whether it's narrower or wider. + if (line.inlines && line.inlines.length > 0) { + node._inlines.unshift(...line.inlines); + } + // Rebuild line with new width + line = this.buildNextLine(node); + continue; + } else { + this.writer.moveToNextPage(node.pageOrientation); + } + } + let positions = this.writer.addLine(line); + node.positions.push(positions); + line = this.buildNextLine(node); + if (line) { + currentHeight += line.getHeight(); + } + } + } + processToc(node) { + if (!node.toc._table && node.toc.hideEmpty === true) { + return; + } + if (node.toc.title) { + this.processNode(node.toc.title); + } + if (node.toc._table) { + this.processNode(node.toc._table); + } + } + buildNextLine(textNode) { + function cloneInline(inline) { + let newInline = inline.constructor(); + for (let key in inline) { + newInline[key] = inline[key]; + } + return newInline; + } + function findMaxFitLength(text, maxWidth, measureFn) { + let low = 1; + let high = text.length; + let bestFit = 1; + while (low <= high) { + const mid = Math.floor((low + high) / 2); + const part = text.substring(0, mid); + const width = measureFn(part); + if (width <= maxWidth) { + bestFit = mid; + low = mid + 1; + } else { + high = mid - 1; + } + } + return bestFit; + } + if (!textNode._inlines || textNode._inlines.length === 0) { + return null; + } + let line = new src_Line(this.writer.context().availableWidth); + const textInlines = new src_TextInlines(null); + let isForceContinue = false; + while (textNode._inlines && textNode._inlines.length > 0 && (line.hasEnoughSpaceForInline(textNode._inlines[0], textNode._inlines.slice(1)) || isForceContinue)) { + let isHardWrap = false; + let inline = textNode._inlines.shift(); + if (!inline.noWrap && inline.text.length > 1 && inline.width > line.getAvailableWidth()) { + let maxChars = findMaxFitLength(inline.text, line.getAvailableWidth(), txt => textInlines.widthOfText(txt, inline)); + if (maxChars < inline.text.length) { + let newInline = cloneInline(inline); + newInline.text = inline.text.substr(maxChars); + inline.text = inline.text.substr(0, maxChars); + newInline.width = textInlines.widthOfText(newInline.text, newInline); + inline.width = textInlines.widthOfText(inline.text, inline); + textNode._inlines.unshift(newInline); + isHardWrap = true; + } + } + line.addInline(inline); + isForceContinue = inline.noNewLine && !isHardWrap; + } + line.lastLineInParagraph = textNode._inlines.length === 0; + return line; + } + + // images + processImage(node) { + let position = this.writer.addImage(node); + node.positions.push(position); + } + processCanvas(node) { + let positions = this.writer.addCanvas(node); + addAll(node.positions, positions); + } + processSVG(node) { + let position = this.writer.addSVG(node); + node.positions.push(position); + } + processQr(node) { + let position = this.writer.addQr(node); + node.positions.push(position); + } + processAttachment(node) { + let position = this.writer.addAttachment(node); + node.positions.push(position); + } +} +function decorateNode(node) { + let x = node.x; + let y = node.y; + node.positions = []; + if (Array.isArray(node.canvas)) { + node.canvas.forEach(vector => { + let x = vector.x; + let y = vector.y; + let x1 = vector.x1; + let y1 = vector.y1; + let x2 = vector.x2; + let y2 = vector.y2; + vector.resetXY = () => { + vector.x = x; + vector.y = y; + vector.x1 = x1; + vector.y1 = y1; + vector.x2 = x2; + vector.y2 = y2; + }; + }); + } + node.resetXY = () => { + node.x = x; + node.y = y; + if (Array.isArray(node.canvas)) { + node.canvas.forEach(vector => { + vector.resetXY(); + }); + } + }; +} +/* harmony default export */ const src_LayoutBuilder = (LayoutBuilder); +// EXTERNAL MODULE: ./node_modules/xmldoc/dist/xmldoc.js +var xmldoc = __webpack_require__(7507); +;// ./src/SVGMeasure.js + + + +/** + * Strip unit postfix, parse number, but return undefined instead of NaN for bad input + * + * @param {string} textVal + * @returns {?number} + */ +const stripUnits = textVal => { + let n = parseFloat(textVal); + if (typeof n !== 'number' || isNaN(n)) { + return undefined; + } + return n; +}; + +/** + * Make sure it's valid XML and the root tag is , returns xmldoc DOM + * + * @param {string} svgString + * @returns {object} + */ +const parseSVG = svgString => { + let doc; + try { + doc = new xmldoc.XmlDocument(svgString); + } catch (error) { + throw new Error('Invalid svg document (' + error + ')', { + cause: error + }); + } + if (doc.name !== "svg") { + throw new Error('Invalid svg document (expected )'); + } + return doc; +}; +class SVGMeasure { + constructor() {} + measureSVG(svg) { + let width, height, viewBox; + if (isString(svg)) { + let doc = parseSVG(svg); + width = doc.attr.width; + height = doc.attr.height; + viewBox = doc.attr.viewBox; + } else if (typeof SVGElement !== 'undefined' && svg instanceof SVGElement && typeof getComputedStyle === 'function') { + width = svg.getAttribute("width"); + height = svg.getAttribute("height"); + viewBox = svg.getAttribute("viewBox"); + } else { + throw new Error('Invalid SVG document'); + } + let docWidth = stripUnits(width); + let docHeight = stripUnits(height); + if ((docWidth === undefined || docHeight === undefined) && typeof viewBox === 'string') { + let viewBoxParts = viewBox.split(/[,\s]+/); + if (viewBoxParts.length !== 4) { + throw new Error("Unexpected svg viewBox format, should have 4 entries but found: '" + viewBox + "'"); + } + if (docWidth === undefined) { + docWidth = stripUnits(viewBoxParts[2]); + } + if (docHeight === undefined) { + docHeight = stripUnits(viewBoxParts[3]); + } + } + return { + width: docWidth, + height: docHeight + }; + } + writeDimensions(svg, dimensions) { + if (isString(svg)) { + let doc = parseSVG(svg); + if (typeof doc.attr.viewBox !== 'string') { + doc.attr.viewBox = `0 0 ${stripUnits(doc.attr.width)} ${stripUnits(doc.attr.height)}`; + } + doc.attr.width = "" + dimensions.width; + doc.attr.height = "" + dimensions.height; + return doc.toString(); + } + if (!svg.hasAttribute('viewBox')) { + svg.setAttribute('viewBox', `0 0 ${stripUnits(svg.getAttribute('width'))} ${stripUnits(svg.getAttribute('height'))}`); + } + svg.setAttribute('width', "" + dimensions.width); + svg.setAttribute('height', "" + dimensions.height); + return svg; + } +} +/* harmony default export */ const src_SVGMeasure = (SVGMeasure); +;// ./src/TextDecorator.js + +const groupDecorations = (line, pdfDocument) => { + let groups = []; + let currentGroup = null; + for (let i = 0, l = line.inlines.length; i < l; i++) { + let inline = line.inlines[i]; + let decoration = inline.decoration; + if (!decoration) { + currentGroup = null; + continue; + } + if (!Array.isArray(decoration)) { + decoration = [decoration]; + } + let color = pdfDocument.resolveColor(pdfDocument.resolveColor(inline.decorationColor, inline.color), 'black'); + let style = inline.decorationStyle || 'solid'; + let thickness = isNumber(inline.decorationThickness) ? inline.decorationThickness : null; + for (let ii = 0, ll = decoration.length; ii < ll; ii++) { + let decorationItem = decoration[ii]; + if (!currentGroup || decorationItem !== currentGroup.decoration || style !== currentGroup.decorationStyle || color !== currentGroup.decorationColor) { + currentGroup = { + line: line, + decoration: decorationItem, + decorationColor: color, + decorationStyle: style, + decorationThickness: thickness, + inlines: [inline] + }; + groups.push(currentGroup); + } else { + currentGroup.inlines.push(inline); + } + } + } + return groups; +}; +class TextDecorator { + constructor(pdfDocument) { + this.pdfDocument = pdfDocument; + } + drawBackground(line, x, y) { + let height = line.getHeight(); + for (let i = 0, l = line.inlines.length; i < l; i++) { + let inline = line.inlines[i]; + let color = this.pdfDocument.resolveColor(inline.background, undefined); + if (!color) { + continue; + } + let patternColor = this.pdfDocument.providePattern(inline.background); + if (patternColor !== null) { + color = patternColor; + } + let justifyShift = inline.justifyShift || 0; + this.pdfDocument.fillColor(color).rect(x + inline.x - justifyShift, y, inline.width + justifyShift, height).fill(); + } + } + drawDecorations(line, x, y) { + let groups = groupDecorations(line, this.pdfDocument); + for (let i = 0, l = groups.length; i < l; i++) { + this._drawDecoration(groups[i], x, y); + } + } + _drawDecoration(group, x, y) { + const maxInline = () => { + let max = 0; + for (let i = 0, l = group.inlines.length; i < l; i++) { + let inline = group.inlines[i]; + max = inline.fontSize > max ? i : max; + } + return group.inlines[max]; + }; + const width = () => { + let sum = 0; + for (let i = 0, l = group.inlines.length; i < l; i++) { + let justifyShift = group.inlines[i].justifyShift || 0; + sum += group.inlines[i].width + justifyShift; + } + return sum; + }; + let firstInline = group.inlines[0]; + let biggerInline = maxInline(); + let totalWidth = width(); + let lineAscent = group.line.getAscenderHeight(); + let ascent = biggerInline.font.ascender / 1000 * biggerInline.fontSize; + let height = biggerInline.height; + let descent = height - ascent; + let lw = isNumber(group.decorationThickness) ? group.decorationThickness : 0.5 + Math.floor(Math.max(biggerInline.fontSize - 8, 0) / 2) * 0.12; + switch (group.decoration) { + case 'underline': + y += lineAscent + descent * 0.45; + break; + case 'overline': + y += lineAscent - ascent * 0.85; + break; + case 'lineThrough': + y += lineAscent - ascent * 0.25; + break; + default: + throw new Error(`Unknown decoration : ${group.decoration}`); + } + if (group.inlines[0].sup) { + y -= group.inlines[0].fontSize * 0.75; + } + if (group.inlines[0].sub) { + y += group.inlines[0].fontSize * 0.35; + } + this.pdfDocument.save(); + if (group.decorationStyle === 'double') { + let gap = Math.max(0.5, lw, biggerInline.fontSize * 0.15); + this.pdfDocument.fillColor(group.decorationColor).rect(x + firstInline.x, y - lw / 2, totalWidth, lw / 2).fill().rect(x + firstInline.x, y + gap - lw / 2, totalWidth, lw / 2).fill(); + } else if (group.decorationStyle === 'dashed') { + let nbDashes = Math.ceil(totalWidth / (3.96 + 2.84)); + let rdx = x + firstInline.x; + this.pdfDocument.rect(rdx, y, totalWidth, lw).clip(); + this.pdfDocument.fillColor(group.decorationColor); + for (let i = 0; i < nbDashes; i++) { + this.pdfDocument.rect(rdx, y - lw / 2, 3.96, lw).fill(); + rdx += 3.96 + 2.84; + } + } else if (group.decorationStyle === 'dotted') { + let nbDots = Math.ceil(totalWidth / (lw * 3)); + let rx = x + firstInline.x; + this.pdfDocument.rect(rx, y, totalWidth, lw).clip(); + this.pdfDocument.fillColor(group.decorationColor); + for (let i = 0; i < nbDots; i++) { + this.pdfDocument.rect(rx, y - lw / 2, lw, lw).fill(); + rx += lw * 3; + } + } else if (group.decorationStyle === 'wavy') { + let sh = 0.7, + sv = 1; + let nbWaves = Math.ceil(totalWidth / (sh * 2)) + 1; + let rwx = x + firstInline.x - 1; + this.pdfDocument.rect(x + firstInline.x, y - sv, totalWidth, y + sv).clip(); + this.pdfDocument.lineWidth(lw / 3); + this.pdfDocument.moveTo(rwx, y); + for (let i = 0; i < nbWaves; i++) { + this.pdfDocument.bezierCurveTo(rwx + sh, y - sv, rwx + sh * 2, y - sv, rwx + sh * 3, y).bezierCurveTo(rwx + sh * 4, y + sv, rwx + sh * 5, y + sv, rwx + sh * 6, y); + rwx += sh * 6; + } + this.pdfDocument.stroke(group.decorationColor); + } else { + this.pdfDocument.fillColor(group.decorationColor).rect(x + firstInline.x, y - lw / 2, totalWidth, lw).fill(); + } + this.pdfDocument.restore(); + } +} +/* harmony default export */ const src_TextDecorator = (TextDecorator); +// EXTERNAL MODULE: ./src/3rd-party/svg-to-pdfkit.js +var svg_to_pdfkit = __webpack_require__(6582); +;// ./src/Renderer.js + + + + +const findFont = (fonts, requiredFonts, defaultFont) => { + for (let i = 0; i < requiredFonts.length; i++) { + let requiredFont = requiredFonts[i].toLowerCase(); + for (let font in fonts) { + if (font.toLowerCase() === requiredFont) { + return font; + } + } + } + return defaultFont; +}; + +/** + * Shift the "y" height of the text baseline up or down (superscript or subscript, + * respectively). The exact shift can / should be changed according to standard + * conventions. + * + * @param {number} y + * @param {object} inline + * @returns {number} + */ +const offsetText = (y, inline) => { + let newY = y; + if (inline.sup) { + newY -= inline.fontSize * 0.75; + } + if (inline.sub) { + newY += inline.fontSize * 0.35; + } + return newY; +}; +class Renderer { + constructor(pdfDocument, progressCallback) { + this.pdfDocument = pdfDocument; + this.progressCallback = progressCallback; + this.outlineMap = []; + } + renderPages(pages) { + this.pdfDocument._pdfMakePages = pages; // TODO: Why? + + let totalItems = 0; + if (this.progressCallback) { + pages.forEach(page => { + totalItems += page.items.length; + }); + } + let renderedItems = 0; + for (let i = 0; i < pages.length; i++) { + this.pdfDocument.addPage({ + size: [pages[i].pageSize.width, pages[i].pageSize.height] + }); + let page = pages[i]; + for (let ii = 0, il = page.items.length; ii < il; ii++) { + let item = page.items[ii]; + switch (item.type) { + case 'vector': + this.renderVector(item.item); + break; + case 'line': + this.renderLine(item.item, item.item.x, item.item.y); + break; + case 'image': + this.renderImage(item.item); + break; + case 'svg': + this.renderSVG(item.item); + break; + case 'attachment': + this.renderAttachment(item.item); + break; + case 'beginClip': + this.beginClip(item.item); + break; + case 'endClip': + this.endClip(); + break; + case 'beginVerticalAlignment': + this.beginVerticalAlignment(item.item); + break; + case 'endVerticalAlignment': + this.endVerticalAlignment(item.item); + break; + } + renderedItems++; + if (this.progressCallback) { + this.progressCallback(renderedItems / totalItems); + } + } + if (page.watermark) { + this.renderWatermark(page); + } + } + } + renderLine(line, x, y) { + function preparePageNodeRefLine(_pageNodeRef, inline) { + let newWidth; + let diffWidth; + let textInlines = new src_TextInlines(null); + if (_pageNodeRef.positions === undefined) { + throw new Error('Page reference id not found'); + } + let pageNumber = _pageNodeRef.positions[0].pageNumber.toString(); + inline.text = pageNumber; + newWidth = textInlines.widthOfText(inline.text, inline); + diffWidth = inline.width - newWidth; + inline.width = newWidth; + switch (inline.alignment) { + case 'right': + inline.x += diffWidth; + break; + case 'center': + inline.x += diffWidth / 2; + break; + } + } + if (line._outline) { + let parentOutline = this.pdfDocument.outline; + if (line._outline.parentId && this.outlineMap[line._outline.parentId]) { + parentOutline = this.outlineMap[line._outline.parentId]; + } + let outline = parentOutline.addItem(line._outline.text, { + expanded: line._outline.expanded + }); + if (line._outline.id) { + this.outlineMap[line._outline.id] = outline; + } + } + if (line._pageNodeRef) { + preparePageNodeRefLine(line._pageNodeRef, line.inlines[0]); + } + x = x || 0; + y = y || 0; + let lineHeight = line.getHeight(); + let ascenderHeight = line.getAscenderHeight(); + let descent = lineHeight - ascenderHeight; + const textDecorator = new src_TextDecorator(this.pdfDocument); + textDecorator.drawBackground(line, x, y); + + //TODO: line.optimizeInlines(); + //TODO: lines without differently styled inlines should be written to pdf as one stream + for (let i = 0, l = line.inlines.length; i < l; i++) { + let inline = line.inlines[i]; + let shiftToBaseline = lineHeight - inline.font.ascender / 1000 * inline.fontSize - descent; + if (inline._pageNodeRef) { + preparePageNodeRefLine(inline._pageNodeRef, inline); + } + let options = { + lineBreak: false, + textWidth: inline.width, + characterSpacing: inline.characterSpacing, + wordCount: 1, + link: inline.link + }; + if (inline.linkToDestination) { + options.goTo = inline.linkToDestination; + } + if (line.id && i === 0) { + options.destination = line.id; + } + if (inline.fontFeatures) { + options.features = inline.fontFeatures; + } + let opacity = isNumber(inline.opacity) ? inline.opacity : 1; + this.pdfDocument.opacity(opacity); + this.pdfDocument.fill(this.pdfDocument.resolveColor(inline.color, 'black')); + this.pdfDocument._font = inline.font; + this.pdfDocument.fontSize(inline.fontSize); + let shiftedY = offsetText(y + shiftToBaseline, inline); + this.pdfDocument.text(inline.text, x + inline.x, shiftedY, options); + if (inline.linkToPage) { + this.pdfDocument.ref({ + Type: 'Action', + S: 'GoTo', + D: [inline.linkToPage, 0, 0] + }).end(); + this.pdfDocument.annotate(x + inline.x, shiftedY, inline.width, inline.height, { + Subtype: 'Link', + Dest: [inline.linkToPage - 1, 'XYZ', null, null, null] + }); + } + } + + // Decorations won't draw correctly for superscript + textDecorator.drawDecorations(line, x, y); + } + renderVector(vector) { + //TODO: pdf optimization (there's no need to write all properties everytime) + this.pdfDocument.lineWidth(vector.lineWidth || 1); + if (vector.dash) { + this.pdfDocument.dash(vector.dash.length, { + space: vector.dash.space || vector.dash.length, + phase: vector.dash.phase || 0 + }); + } else { + this.pdfDocument.undash(); + } + this.pdfDocument.lineJoin(vector.lineJoin || 'miter'); + this.pdfDocument.lineCap(vector.lineCap || 'butt'); + + //TODO: clipping + + let gradient = null; + switch (vector.type) { + case 'ellipse': + this.pdfDocument.ellipse(vector.x, vector.y, vector.r1, vector.r2); + if (vector.linearGradient) { + gradient = this.pdfDocument.linearGradient(vector.x - vector.r1, vector.y, vector.x + vector.r1, vector.y); + } + break; + case 'rect': + if (vector.r) { + this.pdfDocument.roundedRect(vector.x, vector.y, vector.w, vector.h, vector.r); + } else { + this.pdfDocument.rect(vector.x, vector.y, vector.w, vector.h); + } + if (vector.linearGradient) { + gradient = this.pdfDocument.linearGradient(vector.x, vector.y, vector.x + vector.w, vector.y); + } + break; + case 'line': + this.pdfDocument.moveTo(vector.x1, vector.y1); + this.pdfDocument.lineTo(vector.x2, vector.y2); + break; + case 'polyline': + if (vector.points.length === 0) { + break; + } + this.pdfDocument.moveTo(vector.points[0].x, vector.points[0].y); + for (let i = 1, l = vector.points.length; i < l; i++) { + this.pdfDocument.lineTo(vector.points[i].x, vector.points[i].y); + } + if (vector.points.length > 1) { + let p1 = vector.points[0]; + let pn = vector.points[vector.points.length - 1]; + if (vector.closePath || p1.x === pn.x && p1.y === pn.y) { + this.pdfDocument.closePath(); + } + } + break; + case 'path': + this.pdfDocument.path(vector.d); + break; + } + if (vector.linearGradient && gradient) { + let step = 1 / (vector.linearGradient.length - 1); + for (let i = 0; i < vector.linearGradient.length; i++) { + gradient.stop(i * step, vector.linearGradient[i]); + } + vector.color = gradient; + } + let patternColor = this.pdfDocument.providePattern(vector.color); + if (patternColor !== null) { + vector.color = patternColor; + } + let fillOpacity = isNumber(vector.fillOpacity) ? vector.fillOpacity : 1; + let strokeOpacity = isNumber(vector.strokeOpacity) ? vector.strokeOpacity : 1; + if (vector.color && vector.lineColor) { + this.pdfDocument.fillColor(this.pdfDocument.resolveColor(vector.color, 'black'), fillOpacity); + this.pdfDocument.strokeColor(this.pdfDocument.resolveColor(vector.lineColor, 'black'), strokeOpacity); + this.pdfDocument.fillAndStroke(); + } else if (vector.color) { + this.pdfDocument.fillColor(this.pdfDocument.resolveColor(vector.color, 'black'), fillOpacity); + this.pdfDocument.fill(); + } else { + this.pdfDocument.strokeColor(this.pdfDocument.resolveColor(vector.lineColor, 'black'), strokeOpacity); + this.pdfDocument.stroke(); + } + } + renderImage(image) { + let opacity = isNumber(image.opacity) ? image.opacity : 1; + this.pdfDocument.opacity(opacity); + if (image.cover) { + const align = image.cover.align || 'center'; + const valign = image.cover.valign || 'center'; + const width = image.cover.width ? image.cover.width : image.width; + const height = image.cover.height ? image.cover.height : image.height; + this.pdfDocument.save(); + this.pdfDocument.rect(image.x, image.y, width, height).clip(); + this.pdfDocument.image(image.image, image.x, image.y, { + cover: [width, height], + align: align, + valign: valign + }); + this.pdfDocument.restore(); + } else { + this.pdfDocument.image(image.image, image.x, image.y, { + width: image._width, + height: image._height + }); + } + if (image.link) { + this.pdfDocument.link(image.x, image.y, image._width, image._height, image.link); + } + if (image.linkToPage) { + this.pdfDocument.ref({ + Type: 'Action', + S: 'GoTo', + D: [image.linkToPage, 0, 0] + }).end(); + this.pdfDocument.annotate(image.x, image.y, image._width, image._height, { + Subtype: 'Link', + Dest: [image.linkToPage - 1, 'XYZ', null, null, null] + }); + } + if (image.linkToDestination) { + this.pdfDocument.goTo(image.x, image.y, image._width, image._height, image.linkToDestination); + } + if (image.linkToFile) { + const attachment = this.pdfDocument.provideAttachment(image.linkToFile); + this.pdfDocument.fileAnnotation(image.x, image.y, image._width, image._height, attachment, + // add empty rectangle as file annotation appearance with the same size as the rendered image + { + AP: { + N: { + Type: 'XObject', + Subtype: 'Form', + FormType: 1, + BBox: [image.x, image.y, image._width, image._height] + } + } + }); + } + } + renderSVG(svg) { + let options = { + width: svg._width, + height: svg._height, + assumePt: true, + useCSS: !isString(svg.svg), + ...svg.options + }; + options.fontCallback = (family, bold, italic) => { + let fontsFamily = family.split(',').map(f => f.trim().replace(/('|")/g, '')); + let font = findFont(this.pdfDocument.fonts, fontsFamily, svg.font || 'Roboto'); + let fontFile = this.pdfDocument.getFontFile(font, bold, italic); + if (fontFile === null) { + let type = this.pdfDocument.getFontType(bold, italic); + throw new Error(`Font '${font}' in style '${type}' is not defined in the font section of the document definition.`); + } + return fontFile; + }; + (0,svg_to_pdfkit/* default */.A)(this.pdfDocument, svg.svg, svg.x, svg.y, options); + if (svg.link) { + this.pdfDocument.link(svg.x, svg.y, svg._width, svg._height, svg.link); + } + if (svg.linkToPage) { + this.pdfDocument.ref({ + Type: 'Action', + S: 'GoTo', + D: [svg.linkToPage, 0, 0] + }).end(); + this.pdfDocument.annotate(svg.x, svg.y, svg._width, svg._height, { + Subtype: 'Link', + Dest: [svg.linkToPage - 1, 'XYZ', null, null, null] + }); + } + if (svg.linkToDestination) { + this.pdfDocument.goTo(svg.x, svg.y, svg._width, svg._height, svg.linkToDestination); + } + } + renderAttachment(attachment) { + const file = this.pdfDocument.provideAttachment(attachment.attachment); + const options = {}; + if (attachment.icon) { + options.Name = attachment.icon; + } + this.pdfDocument.fileAnnotation(attachment.x, attachment.y, attachment._width, attachment._height, file, options); + } + beginClip(rect) { + this.pdfDocument.save(); + this.pdfDocument.addContent(`${rect.x} ${rect.y} ${rect.width} ${rect.height} re`); + this.pdfDocument.clip(); + } + endClip() { + this.pdfDocument.restore(); + } + beginVerticalAlignment(item) { + if (item.isCellContentMultiPage) { + return; + } + switch (item.verticalAlignment) { + case 'middle': + this.pdfDocument.save(); + this.pdfDocument.translate(0, -(item.getNodeHeight() - item.getViewHeight()) / 2); + break; + case 'bottom': + this.pdfDocument.save(); + this.pdfDocument.translate(0, -(item.getNodeHeight() - item.getViewHeight())); + break; + } + } + endVerticalAlignment(item) { + if (item.isCellContentMultiPage) { + return; + } + switch (item.verticalAlignment) { + case 'middle': + case 'bottom': + this.pdfDocument.restore(); + break; + } + } + renderWatermark(page) { + let watermark = page.watermark; + this.pdfDocument.fill(this.pdfDocument.resolveColor(watermark.color, 'black')); + this.pdfDocument.opacity(watermark.opacity); + this.pdfDocument.save(); + this.pdfDocument.rotate(watermark.angle, { + origin: [this.pdfDocument.page.width / 2, this.pdfDocument.page.height / 2] + }); + let x = this.pdfDocument.page.width / 2 - watermark._size.size.width / 2; + let y = this.pdfDocument.page.height / 2 - watermark._size.size.height / 2; + this.pdfDocument._font = watermark.font; + this.pdfDocument.fontSize(watermark.fontSize); + this.pdfDocument.text(watermark.text, x, y, { + lineBreak: false + }); + this.pdfDocument.restore(); + } +} +/* harmony default export */ const src_Renderer = (Renderer); +;// ./src/Printer.js + + + + + + + + + +class PdfPrinter { + /** + * @param {object} fontDescriptors font definition dictionary + * @param {object} virtualfs + * @param {object} urlResolver + * @param {(path: string) => boolean} localAccessPolicy + */ + constructor(fontDescriptors, virtualfs, urlResolver, localAccessPolicy) { + this.fontDescriptors = fontDescriptors; + this.virtualfs = virtualfs; + this.urlResolver = urlResolver; + this.localAccessPolicy = localAccessPolicy; + } + + /** + * Executes layout engine for the specified document and renders it into a pdfkit document + * ready to be saved. + * + * @param {object} docDefinition + * @param {object} options + * @returns {Promise} resolved promise return a pdfkit document + */ + async createPdfKitDocument(docDefinition, options) { + if (options === void 0) { + options = {}; + } + await this.resolveUrls(docDefinition); + docDefinition.version = docDefinition.version || '1.3'; + docDefinition.subset = docDefinition.subset || undefined; + docDefinition.tagged = typeof docDefinition.tagged === 'boolean' ? docDefinition.tagged : false; + docDefinition.displayTitle = typeof docDefinition.displayTitle === 'boolean' ? docDefinition.displayTitle : false; + docDefinition.compress = typeof docDefinition.compress === 'boolean' ? docDefinition.compress : true; + docDefinition.images = docDefinition.images || {}; + docDefinition.attachments = docDefinition.attachments || {}; + docDefinition.pageMargins = isValue(docDefinition.pageMargins) ? docDefinition.pageMargins : 40; + docDefinition.patterns = docDefinition.patterns || {}; + if (docDefinition.header && typeof docDefinition.header !== 'function') { + docDefinition.header = convertToDynamicContent(docDefinition.header); + } + if (docDefinition.footer && typeof docDefinition.footer !== 'function') { + docDefinition.footer = convertToDynamicContent(docDefinition.footer); + } + let pageSize = normalizePageSize(docDefinition.pageSize, docDefinition.pageOrientation); + let pdfOptions = { + size: [pageSize.width, pageSize.height], + pdfVersion: docDefinition.version, + subset: docDefinition.subset, + tagged: docDefinition.tagged, + displayTitle: docDefinition.displayTitle, + compress: docDefinition.compress, + userPassword: docDefinition.userPassword, + ownerPassword: docDefinition.ownerPassword, + permissions: docDefinition.permissions, + lang: docDefinition.language, + fontLayoutCache: typeof options.fontLayoutCache === 'boolean' ? options.fontLayoutCache : true, + bufferPages: options.bufferPages || false, + autoFirstPage: false, + info: createMetadata(docDefinition), + font: null + }; + this.pdfKitDoc = new src_PDFDocument(this.fontDescriptors, docDefinition.images, docDefinition.patterns, docDefinition.attachments, pdfOptions, this.virtualfs, this.localAccessPolicy); + embedFiles(docDefinition, this.pdfKitDoc); + const builder = new src_LayoutBuilder(pageSize, normalizePageMargin(docDefinition.pageMargins), new src_SVGMeasure()); + builder.registerTableLayouts(tableLayouts); + if (options.tableLayouts) { + builder.registerTableLayouts(options.tableLayouts); + } + let pages = builder.layoutDocument(docDefinition.content, this.pdfKitDoc, docDefinition.styles || {}, docDefinition.defaultStyle || { + fontSize: 12, + font: 'Roboto' + }, docDefinition.background, docDefinition.header, docDefinition.footer, docDefinition.watermark, docDefinition.pageBreakBefore); + let maxNumberPages = docDefinition.maxPagesNumber || -1; + if (isNumber(maxNumberPages) && maxNumberPages > -1) { + pages = pages.slice(0, maxNumberPages); + } + + // if pageSize.height is set to Infinity, calculate the actual height of the page that + // was laid out using the height of each of the items in the page. + pages.forEach(page => { + if (page.pageSize.height === Infinity) { + page.pageSize.height = calculatePageHeight(page, page.pageMargins); + } + }); + const renderer = new src_Renderer(this.pdfKitDoc, options.progressCallback); + renderer.renderPages(pages); + return this.pdfKitDoc; + } + + /** + * @param {object} docDefinition + * @returns {Promise} + */ + async resolveUrls(docDefinition) { + const getExtendedUrl = url => { + if (typeof url === 'object') { + return { + url: url.url, + headers: url.headers + }; + } + return { + url: url, + headers: {} + }; + }; + for (let font in this.fontDescriptors) { + if (this.fontDescriptors.hasOwnProperty(font)) { + if (this.fontDescriptors[font].normal) { + if (Array.isArray(this.fontDescriptors[font].normal)) { + // TrueType Collection + let url = getExtendedUrl(this.fontDescriptors[font].normal[0]); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].normal[0] = url.url; + } else { + let url = getExtendedUrl(this.fontDescriptors[font].normal); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].normal = url.url; + } + } + if (this.fontDescriptors[font].bold) { + if (Array.isArray(this.fontDescriptors[font].bold)) { + // TrueType Collection + let url = getExtendedUrl(this.fontDescriptors[font].bold[0]); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].bold[0] = url.url; + } else { + let url = getExtendedUrl(this.fontDescriptors[font].bold); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].bold = url.url; + } + } + if (this.fontDescriptors[font].italics) { + if (Array.isArray(this.fontDescriptors[font].italics)) { + // TrueType Collection + let url = getExtendedUrl(this.fontDescriptors[font].italics[0]); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].italics[0] = url.url; + } else { + let url = getExtendedUrl(this.fontDescriptors[font].italics); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].italics = url.url; + } + } + if (this.fontDescriptors[font].bolditalics) { + if (Array.isArray(this.fontDescriptors[font].bolditalics)) { + // TrueType Collection + let url = getExtendedUrl(this.fontDescriptors[font].bolditalics[0]); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].bolditalics[0] = url.url; + } else { + let url = getExtendedUrl(this.fontDescriptors[font].bolditalics); + this.urlResolver.resolve(url.url, url.headers); + this.fontDescriptors[font].bolditalics = url.url; + } + } + } + } + if (docDefinition.images) { + for (let image in docDefinition.images) { + if (docDefinition.images.hasOwnProperty(image)) { + let url = getExtendedUrl(docDefinition.images[image]); + this.urlResolver.resolve(url.url, url.headers); + docDefinition.images[image] = url.url; + } + } + } + if (docDefinition.attachments) { + for (let attachment in docDefinition.attachments) { + if (docDefinition.attachments.hasOwnProperty(attachment) && docDefinition.attachments[attachment].src) { + let url = getExtendedUrl(docDefinition.attachments[attachment].src); + this.urlResolver.resolve(url.url, url.headers); + docDefinition.attachments[attachment].src = url.url; + } + } + } + if (docDefinition.files) { + for (let file in docDefinition.files) { + if (docDefinition.files.hasOwnProperty(file) && docDefinition.files[file].src) { + let url = getExtendedUrl(docDefinition.files[file].src); + this.urlResolver.resolve(url.url, url.headers); + docDefinition.files[file].src = url.url; + } + } + } + await this.urlResolver.resolved(); + } +} +function createMetadata(docDefinition) { + // PDF standard has these properties reserved: Title, Author, Subject, Keywords, + // Creator, Producer, CreationDate, ModDate, Trapped. + // To keep the pdfmake api consistent, the info field are defined lowercase. + // Custom properties don't contain a space. + function standardizePropertyKey(key) { + let standardProperties = ['Title', 'Author', 'Subject', 'Keywords', 'Creator', 'Producer', 'CreationDate', 'ModDate', 'Trapped']; + let standardizedKey = key.charAt(0).toUpperCase() + key.slice(1); + if (standardProperties.includes(standardizedKey)) { + return standardizedKey; + } + return key.replace(/\s+/g, ''); + } + let info = { + Producer: 'pdfmake', + Creator: 'pdfmake' + }; + if (docDefinition.info) { + for (let key in docDefinition.info) { + let value = docDefinition.info[key]; + if (value) { + key = standardizePropertyKey(key); + info[key] = value; + } + } + } + return info; +} +function embedFiles(docDefinition, pdfKitDoc) { + if (docDefinition.files) { + for (const key in docDefinition.files) { + const file = docDefinition.files[key]; + if (!file.src) return; + if (pdfKitDoc.virtualfs && pdfKitDoc.virtualfs.existsSync(file.src)) { + file.src = pdfKitDoc.virtualfs.readFileSync(file.src); + } + file.name = file.name || key; + pdfKitDoc.file(file.src, file); + } + } +} +function calculatePageHeight(page, margins) { + function getItemHeight(item) { + if (typeof item.item.getHeight === 'function') { + return item.item.getHeight(); + } else if (item.item._height) { + return item.item._height; + } else if (item.type === 'vector') { + if (typeof item.item.y1 !== 'undefined') { + return item.item.y1 > item.item.y2 ? item.item.y1 : item.item.y2; + } else { + return item.item.h; + } + } else { + // TODO: add support for next item types + return 0; + } + } + function getBottomPosition(item) { + let top = item.item.y || 0; + let height = getItemHeight(item); + return top + height; + } + let fixedMargins = normalizePageMargin(margins || 40); + let height = fixedMargins.top; + page.items.forEach(item => { + let bottomPosition = getBottomPosition(item); + if (bottomPosition > height) { + height = bottomPosition; + } + }); + height += fixedMargins.bottom; + return height; +} +/* harmony default export */ const Printer = (PdfPrinter); +// EXTERNAL MODULE: ./src/virtual-fs.js +var virtual_fs = __webpack_require__(6811); +;// ./src/URLResolver.js +const MAX_REDIRECTS = 30; + +/** + * @param {string} url + * @param {object} headers + * @param {(url: string) => boolean} urlAccessPolicy + * @returns {Promise} + */ +async function fetchUrl(url, headers, urlAccessPolicy) { + if (headers === void 0) { + headers = {}; + } + for (let i = 0; i <= MAX_REDIRECTS; i++) { + if (typeof urlAccessPolicy !== 'undefined' && urlAccessPolicy(url) !== true) { + throw new Error(`Access to URL denied by resource access policy: ${url}`); + } + try { + let response = await fetch(url, { + headers, + redirect: 'manual' + }); + + // redirect url + if (response.status >= 300 && response.status < 400) { + let location = response.headers.get('location'); + if (!location) { + throw new Error('Redirect response missing Location header'); + } + url = new URL(location, url).href; + continue; + } + + // browsers do not support redirect: 'manual' + if (response.type === 'opaqueredirect') { + response = await fetch(url, { + headers + }); + } + if (!response.ok) { + throw new Error(`Failed to fetch (status code: ${response.status})`); + } + return response; + } catch (error) { + throw new Error(`Network request failed (url: "${url}", error: ${error.message})`, { + cause: error + }); + } + } + throw new Error(`Network request failed (url: "${url}", error: Too many redirects)`); +} +class URLResolver { + constructor(fs) { + this.fs = fs; + this.resolving = {}; + this.urlAccessPolicy = undefined; + } + + /** + * @param {(url: string) => boolean} callback + */ + setUrlAccessPolicy(callback) { + this.urlAccessPolicy = callback; + } + resolve(url, headers) { + if (headers === void 0) { + headers = {}; + } + const resolveUrlInternal = async () => { + if (url.toLowerCase().startsWith('https://') || url.toLowerCase().startsWith('http://')) { + if (this.fs.existsSync(url)) { + return; // url was downloaded earlier + } + const response = await fetchUrl(url, headers, this.urlAccessPolicy); + + // validate access policy on redirected url (in browsers, only the final URL is validated) + if (response.redirected) { + if (typeof this.urlAccessPolicy !== 'undefined' && this.urlAccessPolicy(response.url) !== true) { + throw new Error(`Access to URL denied by resource access policy: ${response.url}`); + } + } + const buffer = await response.arrayBuffer(); + this.fs.writeFileSync(url, buffer); + } + // else cannot be resolved + }; + if (!this.resolving[url]) { + this.resolving[url] = resolveUrlInternal(); + } + return this.resolving[url]; + } + resolved() { + return Promise.all(Object.values(this.resolving)); + } +} +/* harmony default export */ const src_URLResolver = (URLResolver); +;// ./src/base.js +/* provided dependency */ var process = __webpack_require__(9964); + + + + + +class pdfmake { + constructor() { + this.virtualfs = virtual_fs["default"]; + this.urlAccessPolicy = undefined; + this.localAccessPolicy = undefined; + } + + /** + * @param {object} docDefinition + * @param {?object} options + * @returns {object} + */ + createPdf(docDefinition, options) { + if (options === void 0) { + options = {}; + } + if (!isObject(docDefinition)) { + throw new Error("Parameter 'docDefinition' has an invalid type. Object expected."); + } + if (!isObject(options)) { + throw new Error("Parameter 'options' has an invalid type. Object expected."); + } + options.progressCallback = this.progressCallback; + options.tableLayouts = this.tableLayouts; + const isServer = typeof process !== 'undefined' && process?.versions?.node; + if (typeof this.urlAccessPolicy === 'undefined' && isServer) { + console.warn('No URL access policy defined. Consider using setUrlAccessPolicy() to restrict external resource downloads.'); + } + if (typeof this.localAccessPolicy === 'undefined' && isServer) { + console.warn('No local access policy defined. Consider using setLocalAccessPolicy() to restrict local file system access.'); + } + let urlResolver = new src_URLResolver(this.virtualfs); + urlResolver.setUrlAccessPolicy(this.urlAccessPolicy); + let printer = new Printer(this.fonts, this.virtualfs, urlResolver, this.localAccessPolicy); + const pdfDocumentPromise = printer.createPdfKitDocument(docDefinition, options); + return this._transformToDocument(pdfDocumentPromise); + } + + /** + * @param {(url: string) => boolean} callback + */ + setUrlAccessPolicy(callback) { + if (callback !== undefined && typeof callback !== 'function') { + throw new Error("Parameter 'callback' has an invalid type. Function or undefined expected."); + } + this.urlAccessPolicy = callback; + } + setProgressCallback(callback) { + this.progressCallback = callback; + } + addTableLayouts(tableLayouts) { + this.tableLayouts = pack(this.tableLayouts, tableLayouts); + } + setTableLayouts(tableLayouts) { + this.tableLayouts = tableLayouts; + } + clearTableLayouts() { + this.tableLayouts = {}; + } + addFonts(fonts) { + this.fonts = pack(this.fonts, fonts); + } + setFonts(fonts) { + this.fonts = fonts; + } + clearFonts() { + this.fonts = {}; + } + _transformToDocument(doc) { + return doc; + } +} +/* harmony default export */ const base = (pdfmake); +;// ./src/OutputDocument.js +/* provided dependency */ var OutputDocument_Buffer = __webpack_require__(783)["Buffer"]; +class OutputDocument { + /** + * @param {Promise} pdfDocumentPromise + */ + constructor(pdfDocumentPromise) { + this.bufferSize = 1073741824; + this.pdfDocumentPromise = pdfDocumentPromise; + this.bufferPromise = null; + } + + /** + * @returns {Promise} + */ + getStream() { + return this.pdfDocumentPromise; + } + + /** + * @returns {Promise} + */ + getBuffer() { + const getBufferInternal = async () => { + const stream = await this.getStream(); + return new Promise(resolve => { + let chunks = []; + stream.on('readable', () => { + let chunk; + while ((chunk = stream.read(this.bufferSize)) !== null) { + chunks.push(chunk); + } + }); + stream.on('end', () => { + resolve(OutputDocument_Buffer.concat(chunks)); + }); + stream.end(); + }); + }; + if (this.bufferPromise === null) { + this.bufferPromise = getBufferInternal(); + } + return this.bufferPromise; + } + + /** + * @returns {Promise} + */ + async getBase64() { + const buffer = await this.getBuffer(); + return buffer.toString('base64'); + } + + /** + * @returns {Promise} + */ + async getDataUrl() { + const data = await this.getBase64(); + return 'data:application/pdf;base64,' + data; + } +} +/* harmony default export */ const src_OutputDocument = (OutputDocument); +// EXTERNAL MODULE: ./node_modules/file-saver/dist/FileSaver.min.js +var FileSaver_min = __webpack_require__(8679); +;// ./src/browser-extensions/OutputDocumentBrowser.js + + + +/** + * @returns {Window} + */ +const openWindow = () => { + // we have to open the window immediately and store the reference + // otherwise popup blockers will stop us + let win = window.open('', '_blank'); + if (win === null) { + throw new Error('Open PDF in new window blocked by browser'); + } + return win; +}; +class OutputDocumentBrowser extends src_OutputDocument { + /** + * @returns {Promise} + */ + async getBlob() { + const buffer = await this.getBuffer(); + return new Blob([buffer], { + type: 'application/pdf' + }); + } + + /** + * @param {string} filename + * @returns {Promise} + */ + async download(filename) { + if (filename === void 0) { + filename = 'file.pdf'; + } + const blob = await this.getBlob(); + (0,FileSaver_min.saveAs)(blob, filename); + } + + /** + * @param {Window} win + * @returns {Promise} + */ + async open(win) { + if (win === void 0) { + win = null; + } + if (!win) { + win = openWindow(); + } + const blob = await this.getBlob(); + try { + let urlCreator = window.URL || window.webkitURL; + let pdfUrl = urlCreator.createObjectURL(blob); + win.location.href = pdfUrl; + + /* temporarily disabled + if (win === window) { + return; + } else { + setTimeout(() => { + if (win.window === null) { // is closed by AdBlock + window.location.href = pdfUrl; // open in actual window + } + return; + }, 500); + } + */ + } catch (e) { + win.close(); + throw e; + } + } + + /** + * @param {Window} win + * @returns {Promise} + */ + async print(win) { + if (win === void 0) { + win = null; + } + const stream = await this.getStream(); + stream.setOpenActionAsPrint(); + await this.open(win); + } +} +/* harmony default export */ const browser_extensions_OutputDocumentBrowser = (OutputDocumentBrowser); +// EXTERNAL MODULE: ./src/browser-extensions/virtual-fs-cjs.js +var virtual_fs_cjs = __webpack_require__(2416); +var virtual_fs_cjs_default = /*#__PURE__*/__webpack_require__.n(virtual_fs_cjs); +// EXTERNAL MODULE: ./node_modules/core-js/configurator.js +var configurator = __webpack_require__(890); +var configurator_default = /*#__PURE__*/__webpack_require__.n(configurator); +;// ./src/browser-extensions/index.js + + + + + +// core-js: Polyfills will be used only if natives completely unavailable. +configurator_default()({ + useNative: ['Promise'] +}); +let defaultClientFonts = { + Roboto: { + normal: 'Roboto-Regular.ttf', + bold: 'Roboto-Medium.ttf', + italics: 'Roboto-Italic.ttf', + bolditalics: 'Roboto-MediumItalic.ttf' + } +}; +class browser_extensions_pdfmake extends base { + constructor() { + super(); + this.fonts = defaultClientFonts; + } + addFontContainer(fontContainer) { + this.addVirtualFileSystem(fontContainer.vfs); + this.addFonts(fontContainer.fonts); + } + addVirtualFileSystem(vfs) { + for (let key in vfs) { + if (vfs.hasOwnProperty(key)) { + let data; + let encoding; + if (typeof vfs[key] === 'object') { + data = vfs[key].data; + encoding = vfs[key].encoding || 'base64'; + } else { + data = vfs[key]; + encoding = 'base64'; + } + virtual_fs_cjs_default().writeFileSync(key, data, encoding); + } + } + } + _transformToDocument(doc) { + return new browser_extensions_OutputDocumentBrowser(doc); + } +} +/* harmony default export */ const browser_extensions = (new browser_extensions_pdfmake()); + +/***/ }, + +/***/ 2736 +(module, __unused_webpack_exports, __webpack_require__) { + +module.exports = __webpack_require__(7133)["default"]; + +/***/ }, + +/***/ 2416 +(module, __unused_webpack_exports, __webpack_require__) { + +module.exports = __webpack_require__(6811)["default"]; + +/***/ }, + +/***/ 6811 +(__unused_webpack_module, __webpack_exports__, __webpack_require__) { + +"use strict"; +var __webpack_dirname__ = "/"; +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* provided dependency */ var Buffer = __webpack_require__(783)["Buffer"]; +const normalizeFilename = filename => { + if (filename.indexOf(__webpack_dirname__) === 0) { + filename = filename.substring(__webpack_dirname__.length); + } + if (filename.indexOf('/') === 0) { + filename = filename.substring(1); + } + return filename; +}; +class VirtualFileSystem { + constructor() { + this.storage = {}; + } + + /** + * @param {string} filename + * @returns {boolean} + */ + existsSync(filename) { + const normalizedFilename = normalizeFilename(filename); + return typeof this.storage[normalizedFilename] !== 'undefined'; + } + + /** + * @param {string} filename + * @param {?string|?object} options + * @returns {string|Buffer} + */ + readFileSync(filename, options) { + const normalizedFilename = normalizeFilename(filename); + const encoding = typeof options === 'object' ? options.encoding : options; + if (!this.existsSync(normalizedFilename)) { + throw new Error(`File '${normalizedFilename}' not found in virtual file system`); + } + const buffer = this.storage[normalizedFilename]; + if (encoding) { + return buffer.toString(encoding); + } + return buffer; + } + + /** + * @param {string} filename + * @param {string|Buffer} content + * @param {?string|?object} options + */ + writeFileSync(filename, content, options) { + const normalizedFilename = normalizeFilename(filename); + const encoding = typeof options === 'object' ? options.encoding : options; + if (!content && !options) { + throw new Error('No content'); + } + this.storage[normalizedFilename] = encoding || typeof content === 'string' ? new Buffer(content, encoding) : content; + } +} +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (new VirtualFileSystem()); + +/***/ }, + +/***/ 6582 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +var __webpack_unused_export__; + + +__webpack_unused_export__ = ({ + value: true +}); +exports.A = void 0; +var _source = _interopRequireDefault(__webpack_require__(7696)); +function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +var _default = exports.A = _source.default; + +/***/ }, + +/***/ 7696 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* module decorator */ module = __webpack_require__.nmd(module); + + +var SVGtoPDF = function (doc, svg, x, y, options) { + "use strict"; + + const NamedColors = { + aliceblue: [240, 248, 255], + antiquewhite: [250, 235, 215], + aqua: [0, 255, 255], + aquamarine: [127, 255, 212], + azure: [240, 255, 255], + beige: [245, 245, 220], + bisque: [255, 228, 196], + black: [0, 0, 0], + blanchedalmond: [255, 235, 205], + blue: [0, 0, 255], + blueviolet: [138, 43, 226], + brown: [165, 42, 42], + burlywood: [222, 184, 135], + cadetblue: [95, 158, 160], + chartreuse: [127, 255, 0], + chocolate: [210, 105, 30], + coral: [255, 127, 80], + cornflowerblue: [100, 149, 237], + cornsilk: [255, 248, 220], + crimson: [220, 20, 60], + cyan: [0, 255, 255], + darkblue: [0, 0, 139], + darkcyan: [0, 139, 139], + darkgoldenrod: [184, 134, 11], + darkgray: [169, 169, 169], + darkgrey: [169, 169, 169], + darkgreen: [0, 100, 0], + darkkhaki: [189, 183, 107], + darkmagenta: [139, 0, 139], + darkolivegreen: [85, 107, 47], + darkorange: [255, 140, 0], + darkorchid: [153, 50, 204], + darkred: [139, 0, 0], + darksalmon: [233, 150, 122], + darkseagreen: [143, 188, 143], + darkslateblue: [72, 61, 139], + darkslategray: [47, 79, 79], + darkslategrey: [47, 79, 79], + darkturquoise: [0, 206, 209], + darkviolet: [148, 0, 211], + deeppink: [255, 20, 147], + deepskyblue: [0, 191, 255], + dimgray: [105, 105, 105], + dimgrey: [105, 105, 105], + dodgerblue: [30, 144, 255], + firebrick: [178, 34, 34], + floralwhite: [255, 250, 240], + forestgreen: [34, 139, 34], + fuchsia: [255, 0, 255], + gainsboro: [220, 220, 220], + ghostwhite: [248, 248, 255], + gold: [255, 215, 0], + goldenrod: [218, 165, 32], + gray: [128, 128, 128], + grey: [128, 128, 128], + green: [0, 128, 0], + greenyellow: [173, 255, 47], + honeydew: [240, 255, 240], + hotpink: [255, 105, 180], + indianred: [205, 92, 92], + indigo: [75, 0, 130], + ivory: [255, 255, 240], + khaki: [240, 230, 140], + lavender: [230, 230, 250], + lavenderblush: [255, 240, 245], + lawngreen: [124, 252, 0], + lemonchiffon: [255, 250, 205], + lightblue: [173, 216, 230], + lightcoral: [240, 128, 128], + lightcyan: [224, 255, 255], + lightgoldenrodyellow: [250, 250, 210], + lightgray: [211, 211, 211], + lightgrey: [211, 211, 211], + lightgreen: [144, 238, 144], + lightpink: [255, 182, 193], + lightsalmon: [255, 160, 122], + lightseagreen: [32, 178, 170], + lightskyblue: [135, 206, 250], + lightslategray: [119, 136, 153], + lightslategrey: [119, 136, 153], + lightsteelblue: [176, 196, 222], + lightyellow: [255, 255, 224], + lime: [0, 255, 0], + limegreen: [50, 205, 50], + linen: [250, 240, 230], + magenta: [255, 0, 255], + maroon: [128, 0, 0], + mediumaquamarine: [102, 205, 170], + mediumblue: [0, 0, 205], + mediumorchid: [186, 85, 211], + mediumpurple: [147, 112, 219], + mediumseagreen: [60, 179, 113], + mediumslateblue: [123, 104, 238], + mediumspringgreen: [0, 250, 154], + mediumturquoise: [72, 209, 204], + mediumvioletred: [199, 21, 133], + midnightblue: [25, 25, 112], + mintcream: [245, 255, 250], + mistyrose: [255, 228, 225], + moccasin: [255, 228, 181], + navajowhite: [255, 222, 173], + navy: [0, 0, 128], + oldlace: [253, 245, 230], + olive: [128, 128, 0], + olivedrab: [107, 142, 35], + orange: [255, 165, 0], + orangered: [255, 69, 0], + orchid: [218, 112, 214], + palegoldenrod: [238, 232, 170], + palegreen: [152, 251, 152], + paleturquoise: [175, 238, 238], + palevioletred: [219, 112, 147], + papayawhip: [255, 239, 213], + peachpuff: [255, 218, 185], + peru: [205, 133, 63], + pink: [255, 192, 203], + plum: [221, 160, 221], + powderblue: [176, 224, 230], + purple: [128, 0, 128], + rebeccapurple: [102, 51, 153], + red: [255, 0, 0], + rosybrown: [188, 143, 143], + royalblue: [65, 105, 225], + saddlebrown: [139, 69, 19], + salmon: [250, 128, 114], + sandybrown: [244, 164, 96], + seagreen: [46, 139, 87], + seashell: [255, 245, 238], + sienna: [160, 82, 45], + silver: [192, 192, 192], + skyblue: [135, 206, 235], + slateblue: [106, 90, 205], + slategray: [112, 128, 144], + slategrey: [112, 128, 144], + snow: [255, 250, 250], + springgreen: [0, 255, 127], + steelblue: [70, 130, 180], + tan: [210, 180, 140], + teal: [0, 128, 128], + thistle: [216, 191, 216], + tomato: [255, 99, 71], + turquoise: [64, 224, 208], + violet: [238, 130, 238], + wheat: [245, 222, 179], + white: [255, 255, 255], + whitesmoke: [245, 245, 245], + yellow: [255, 255, 0] + }; + const DefaultColors = { + black: [NamedColors.black, 1], + white: [NamedColors.white, 1], + transparent: [NamedColors.black, 0] + }; + const Entities = { + quot: 34, + amp: 38, + lt: 60, + gt: 62, + apos: 39, + OElig: 338, + oelig: 339, + Scaron: 352, + scaron: 353, + Yuml: 376, + circ: 710, + tilde: 732, + ensp: 8194, + emsp: 8195, + thinsp: 8201, + zwnj: 8204, + zwj: 8205, + lrm: 8206, + rlm: 8207, + ndash: 8211, + mdash: 8212, + lsquo: 8216, + rsquo: 8217, + sbquo: 8218, + ldquo: 8220, + rdquo: 8221, + bdquo: 8222, + dagger: 8224, + Dagger: 8225, + permil: 8240, + lsaquo: 8249, + rsaquo: 8250, + euro: 8364, + nbsp: 160, + iexcl: 161, + cent: 162, + pound: 163, + curren: 164, + yen: 165, + brvbar: 166, + sect: 167, + uml: 168, + copy: 169, + ordf: 170, + laquo: 171, + not: 172, + shy: 173, + reg: 174, + macr: 175, + deg: 176, + plusmn: 177, + sup2: 178, + sup3: 179, + acute: 180, + micro: 181, + para: 182, + middot: 183, + cedil: 184, + sup1: 185, + ordm: 186, + raquo: 187, + frac14: 188, + frac12: 189, + frac34: 190, + iquest: 191, + Agrave: 192, + Aacute: 193, + Acirc: 194, + Atilde: 195, + Auml: 196, + Aring: 197, + AElig: 198, + Ccedil: 199, + Egrave: 200, + Eacute: 201, + Ecirc: 202, + Euml: 203, + Igrave: 204, + Iacute: 205, + Icirc: 206, + Iuml: 207, + ETH: 208, + Ntilde: 209, + Ograve: 210, + Oacute: 211, + Ocirc: 212, + Otilde: 213, + Ouml: 214, + times: 215, + Oslash: 216, + Ugrave: 217, + Uacute: 218, + Ucirc: 219, + Uuml: 220, + Yacute: 221, + THORN: 222, + szlig: 223, + agrave: 224, + aacute: 225, + acirc: 226, + atilde: 227, + auml: 228, + aring: 229, + aelig: 230, + ccedil: 231, + egrave: 232, + eacute: 233, + ecirc: 234, + euml: 235, + igrave: 236, + iacute: 237, + icirc: 238, + iuml: 239, + eth: 240, + ntilde: 241, + ograve: 242, + oacute: 243, + ocirc: 244, + otilde: 245, + ouml: 246, + divide: 247, + oslash: 248, + ugrave: 249, + uacute: 250, + ucirc: 251, + uuml: 252, + yacute: 253, + thorn: 254, + yuml: 255, + fnof: 402, + Alpha: 913, + Beta: 914, + Gamma: 915, + Delta: 916, + Epsilon: 917, + Zeta: 918, + Eta: 919, + Theta: 920, + Iota: 921, + Kappa: 922, + Lambda: 923, + Mu: 924, + Nu: 925, + Xi: 926, + Omicron: 927, + Pi: 928, + Rho: 929, + Sigma: 931, + Tau: 932, + Upsilon: 933, + Phi: 934, + Chi: 935, + Psi: 936, + Omega: 937, + alpha: 945, + beta: 946, + gamma: 947, + delta: 948, + epsilon: 949, + zeta: 950, + eta: 951, + theta: 952, + iota: 953, + kappa: 954, + lambda: 955, + mu: 956, + nu: 957, + xi: 958, + omicron: 959, + pi: 960, + rho: 961, + sigmaf: 962, + sigma: 963, + tau: 964, + upsilon: 965, + phi: 966, + chi: 967, + psi: 968, + omega: 969, + thetasym: 977, + upsih: 978, + piv: 982, + bull: 8226, + hellip: 8230, + prime: 8242, + Prime: 8243, + oline: 8254, + frasl: 8260, + weierp: 8472, + image: 8465, + real: 8476, + trade: 8482, + alefsym: 8501, + larr: 8592, + uarr: 8593, + rarr: 8594, + darr: 8595, + harr: 8596, + crarr: 8629, + lArr: 8656, + uArr: 8657, + rArr: 8658, + dArr: 8659, + hArr: 8660, + forall: 8704, + part: 8706, + exist: 8707, + empty: 8709, + nabla: 8711, + isin: 8712, + notin: 8713, + ni: 8715, + prod: 8719, + sum: 8721, + minus: 8722, + lowast: 8727, + radic: 8730, + prop: 8733, + infin: 8734, + ang: 8736, + and: 8743, + or: 8744, + cap: 8745, + cup: 8746, + int: 8747, + there4: 8756, + sim: 8764, + cong: 8773, + asymp: 8776, + ne: 8800, + equiv: 8801, + le: 8804, + ge: 8805, + sub: 8834, + sup: 8835, + nsub: 8836, + sube: 8838, + supe: 8839, + oplus: 8853, + otimes: 8855, + perp: 8869, + sdot: 8901, + lceil: 8968, + rceil: 8969, + lfloor: 8970, + rfloor: 8971, + lang: 9001, + rang: 9002, + loz: 9674, + spades: 9824, + clubs: 9827, + hearts: 9829, + diams: 9830 + }; + const PathArguments = { + A: 7, + a: 7, + C: 6, + c: 6, + H: 1, + h: 1, + L: 2, + l: 2, + M: 2, + m: 2, + Q: 4, + q: 4, + S: 4, + s: 4, + T: 2, + t: 2, + V: 1, + v: 1, + Z: 0, + z: 0 + }; + const PathFlags = { + A3: true, + A4: true, + a3: true, + a4: true + }; + const Properties = { + 'color': { + inherit: true, + initial: undefined + }, + 'visibility': { + inherit: true, + initial: 'visible', + values: { + 'hidden': 'hidden', + 'collapse': 'hidden', + 'visible': 'visible' + } + }, + 'fill': { + inherit: true, + initial: DefaultColors.black + }, + 'stroke': { + inherit: true, + initial: 'none' + }, + 'stop-color': { + inherit: false, + initial: DefaultColors.black + }, + 'fill-opacity': { + inherit: true, + initial: 1 + }, + 'stroke-opacity': { + inherit: true, + initial: 1 + }, + 'stop-opacity': { + inherit: false, + initial: 1 + }, + 'fill-rule': { + inherit: true, + initial: 'nonzero', + values: { + 'nonzero': 'nonzero', + 'evenodd': 'evenodd' + } + }, + 'clip-rule': { + inherit: true, + initial: 'nonzero', + values: { + 'nonzero': 'nonzero', + 'evenodd': 'evenodd' + } + }, + 'stroke-width': { + inherit: true, + initial: 1 + }, + 'stroke-dasharray': { + inherit: true, + initial: [] + }, + 'stroke-dashoffset': { + inherit: true, + initial: 0 + }, + 'stroke-miterlimit': { + inherit: true, + initial: 4 + }, + 'stroke-linejoin': { + inherit: true, + initial: 'miter', + values: { + 'miter': 'miter', + 'round': 'round', + 'bevel': 'bevel' + } + }, + 'stroke-linecap': { + inherit: true, + initial: 'butt', + values: { + 'butt': 'butt', + 'round': 'round', + 'square': 'square' + } + }, + 'font-size': { + inherit: true, + initial: 16, + values: { + 'xx-small': 9, + 'x-small': 10, + 'small': 13, + 'medium': 16, + 'large': 18, + 'x-large': 24, + 'xx-large': 32 + } + }, + 'font-family': { + inherit: true, + initial: 'sans-serif' + }, + 'font-weight': { + inherit: true, + initial: 'normal', + values: { + '600': 'bold', + '700': 'bold', + '800': 'bold', + '900': 'bold', + 'bold': 'bold', + 'bolder': 'bold', + '500': 'normal', + '400': 'normal', + '300': 'normal', + '200': 'normal', + '100': 'normal', + 'normal': 'normal', + 'lighter': 'normal' + } + }, + 'font-style': { + inherit: true, + initial: 'normal', + values: { + 'italic': 'italic', + 'oblique': 'italic', + 'normal': 'normal' + } + }, + 'text-anchor': { + inherit: true, + initial: 'start', + values: { + 'start': 'start', + 'middle': 'middle', + 'end': 'end' + } + }, + 'direction': { + inherit: true, + initial: 'ltr', + values: { + 'ltr': 'ltr', + 'rtl': 'rtl' + } + }, + 'dominant-baseline': { + inherit: true, + initial: 'baseline', + values: { + 'auto': 'baseline', + 'baseline': 'baseline', + 'before-edge': 'before-edge', + 'text-before-edge': 'before-edge', + 'middle': 'middle', + 'central': 'central', + 'after-edge': 'after-edge', + 'text-after-edge': 'after-edge', + 'ideographic': 'ideographic', + 'alphabetic': 'alphabetic', + 'hanging': 'hanging', + 'mathematical': 'mathematical' + } + }, + 'alignment-baseline': { + inherit: false, + initial: undefined, + values: { + 'auto': 'baseline', + 'baseline': 'baseline', + 'before-edge': 'before-edge', + 'text-before-edge': 'before-edge', + 'middle': 'middle', + 'central': 'central', + 'after-edge': 'after-edge', + 'text-after-edge': 'after-edge', + 'ideographic': 'ideographic', + 'alphabetic': 'alphabetic', + 'hanging': 'hanging', + 'mathematical': 'mathematical' + } + }, + 'baseline-shift': { + inherit: true, + initial: 'baseline', + values: { + 'baseline': 'baseline', + 'sub': 'sub', + 'super': 'super' + } + }, + 'word-spacing': { + inherit: true, + initial: 0, + values: { + normal: 0 + } + }, + 'letter-spacing': { + inherit: true, + initial: 0, + values: { + normal: 0 + } + }, + 'text-decoration': { + inherit: false, + initial: 'none', + values: { + 'none': 'none', + 'underline': 'underline', + 'overline': 'overline', + 'line-through': 'line-through' + } + }, + 'xml:space': { + inherit: true, + initial: 'default', + css: 'white-space', + values: { + 'preserve': 'preserve', + 'default': 'default', + 'pre': 'preserve', + 'pre-line': 'preserve', + 'pre-wrap': 'preserve', + 'nowrap': 'default' + } + }, + 'marker-start': { + inherit: true, + initial: 'none' + }, + 'marker-mid': { + inherit: true, + initial: 'none' + }, + 'marker-end': { + inherit: true, + initial: 'none' + }, + 'opacity': { + inherit: false, + initial: 1 + }, + 'transform': { + inherit: false, + initial: [1, 0, 0, 1, 0, 0] + }, + 'display': { + inherit: false, + initial: 'inline', + values: { + 'none': 'none', + 'inline': 'inline', + 'block': 'inline' + } + }, + 'clip-path': { + inherit: false, + initial: 'none' + }, + 'mask': { + inherit: false, + initial: 'none' + }, + 'overflow': { + inherit: false, + initial: 'hidden', + values: { + 'hidden': 'hidden', + 'scroll': 'hidden', + 'visible': 'visible' + } + }, + 'vector-effect': { + inherit: true, + initial: 'none', + values: { + 'none': 'none', + 'non-scaling-stroke': 'non-scaling-stroke' + } + } + }; + function docBeginGroup(bbox) { + let group = new function PDFGroup() {}(); + group.name = 'G' + (doc._groupCount = (doc._groupCount || 0) + 1); + group.resources = doc.ref(); + group.xobj = doc.ref({ + Type: 'XObject', + Subtype: 'Form', + FormType: 1, + BBox: bbox, + Group: { + S: 'Transparency', + CS: 'DeviceRGB', + I: true, + K: false + }, + Resources: group.resources + }); + group.xobj.write(''); + group.savedMatrix = doc._ctm; + group.savedPage = doc.page; + groupStack.push(group); + doc._ctm = [1, 0, 0, 1, 0, 0]; + doc.page = { + width: doc.page.width, + height: doc.page.height, + write: function (data) { + group.xobj.write(data); + }, + fonts: {}, + xobjects: {}, + ext_gstates: {}, + patterns: {} + }; + return group; + } + function docEndGroup(group) { + if (group !== groupStack.pop()) { + throw 'Group not matching'; + } + if (Object.keys(doc.page.fonts).length) { + group.resources.data.Font = doc.page.fonts; + } + if (Object.keys(doc.page.xobjects).length) { + group.resources.data.XObject = doc.page.xobjects; + } + if (Object.keys(doc.page.ext_gstates).length) { + group.resources.data.ExtGState = doc.page.ext_gstates; + } + if (Object.keys(doc.page.patterns).length) { + group.resources.data.Pattern = doc.page.patterns; + } + group.resources.end(); + group.xobj.end(); + doc._ctm = group.savedMatrix; + doc.page = group.savedPage; + } + function docInsertGroup(group) { + doc.page.xobjects[group.name] = group.xobj; + doc.addContent('/' + group.name + ' Do'); + } + function docApplyMask(group, clip) { + let name = 'M' + (doc._maskCount = (doc._maskCount || 0) + 1); + let gstate = doc.ref({ + Type: 'ExtGState', + CA: 1, + ca: 1, + BM: 'Normal', + SMask: { + S: 'Luminosity', + G: group.xobj, + BC: clip ? [0, 0, 0] : [1, 1, 1] + } + }); + gstate.end(); + doc.page.ext_gstates[name] = gstate; + doc.addContent('/' + name + ' gs'); + } + function docCreatePattern(group, dx, dy, matrix) { + let pattern = { + type: 'PDFPattern', + group: group, + dx: dx, + dy: dy, + matrix: matrix || [1, 0, 0, 1, 0, 0] + }; + return pattern; + } + function docUsePattern(pattern, stroke) { + let name = 'P' + (doc._patternCount = (doc._patternCount || 0) + 1); + let ref = doc.ref({ + Type: 'Pattern', + PatternType: 1, + PaintType: 1, + TilingType: 2, + BBox: [0, 0, pattern.dx, pattern.dy], + XStep: pattern.dx, + YStep: pattern.dy, + Matrix: multiplyMatrix(doc._ctm, pattern.matrix), + Resources: { + ProcSet: ['PDF', 'Text', 'ImageB', 'ImageC', 'ImageI'], + XObject: function () { + let temp = {}; + temp[pattern.group.name] = pattern.group.xobj; + return temp; + }() + } + }); + ref.write('/' + pattern.group.name + ' Do'); + ref.end(); + doc.page.patterns[name] = ref; + if (stroke) { + doc.addContent('/Pattern CS'); + doc.addContent('/' + name + ' SCN'); + } else { + doc.addContent('/Pattern cs'); + doc.addContent('/' + name + ' scn'); + } + } + function docBeginText(font, size) { + if (!doc.page.fonts[font.id]) { + doc.page.fonts[font.id] = font.ref(); + } + doc.addContent('BT').addContent('/' + font.id + ' ' + size + ' Tf'); + } + function docSetTextMatrix(a, b, c, d, e, f) { + doc.addContent(validateNumber(a) + ' ' + validateNumber(b) + ' ' + validateNumber(-c) + ' ' + validateNumber(-d) + ' ' + validateNumber(e) + ' ' + validateNumber(f) + ' Tm'); + } + function docSetTextMode(fill, stroke) { + let mode = fill && stroke ? 2 : stroke ? 1 : fill ? 0 : 3; + doc.addContent(mode + ' Tr'); + } + function docWriteGlyphs(positions, font) { + let commands = []; + let commandStr = ''; + const skew = font.fauxItalic ? -0.25 : 0; + + // Add the given character to the 'TJ' command string. + function addChar(char) { + commandStr += char.glyph; + if (char.kern === 0) return; + commands.push(`<${commandStr}> ${validateNumber(char.kern)}`); + commandStr = ''; + } + ; + + // Flush the current TJ command string to the output stream. + function flush() { + if (commandStr.length) { + commands.push(`<${commandStr}> 0`); + commandStr = ''; + } + if (commands.length) { + doc.addContent(`[${commands.join(' ')}] TJ`); + commands = []; + } + } + ; + for (let i = 0; i < positions.length; i++) { + const pos = positions[i]; + if (pos.hidden || isEqual(pos.width, 0)) { + flush(); + continue; + } + if (pos.continuous) { + addChar(pos); + continue; + } + + // If this character is non-continuous, flush the command buffer. + flush(); + + // Start a new TJ command after writing a Text Matrix (Tm) + const cos = Math.cos(pos.rotate); + const sin = Math.sin(pos.rotate); + docSetTextMatrix(cos * pos.scale, sin * pos.scale, cos * skew - sin, sin * skew + cos, pos.x, pos.y); + addChar(pos); + } + ; + + // Flush any remaining characters in the buffer. + flush(); + } + function docEndText() { + doc.addContent('ET'); + } + function docFillColor(color) { + if (color[0].type === 'PDFPattern') { + doc.fillOpacity(color[1]); + docUsePattern(color[0], false); + } else { + doc.fillColor(color[0], color[1]); + } + } + function docStrokeColor(color) { + if (color[0].type === 'PDFPattern') { + doc.strokeOpacity(color[1]); + docUsePattern(color[0], true); + } else { + doc.strokeColor(color[0], color[1]); + } + } + // PDFKit doesn't accept any 0s in the dash array, but that's perfectly + // valid in SVG. So this function applys a dash array and offset, detecting + // any 0s in the dash array and updating it and the dash offset as needed to + // remove the zeros, but preserve the end result. + // + // `dashArray` must have an even number of elements + function docApplyDash(dashArray, dashOffset) { + let index; + // Anytime there's a 0 that isn't the first or last element of the array, + // we can remove it by combining the previous or next value. If it's a + // dash, then it's a zero-length dash between two spaces, so the dash can + // be eliminated and spaces combined by summing them, replacing all three + // values with the sum of the two spaces. If the 0 value is a space, then + // it's a zero-length space between two dashes, and the dashes can be + // similarly combined. So first we run that logic iteratively to remove + // all the 0s from the dash array that aren't the first or last element. + // Note that because we replace 3 values with one value, this doesn't + // change the even-ness of the length of dashArray. + while ((index = dashArray.slice(1, -1).indexOf(0)) !== -1) { + let actualIndex = index + 1; + let replacementValue = dashArray[actualIndex - 1] + dashArray[actualIndex + 1]; + dashArray = dashArray.slice(0, actualIndex - 1).concat([replacementValue]).concat(dashArray.slice(actualIndex + 2)); + } + + // The stroke array only having two elements (a dash value and space + // value) is a special case. + if (dashArray.length === 2) { + if (dashArray[0] === 0) { + // Regardless of the space value, the dash length is zero, so we're + // not actually drawing a stroke. We can't describe that in a + // doc.dash() call in a way that PDFKit will accept, so we set the + // stroke opacity to zero as our best approximation. + doc.strokeOpacity(0); + return; + } else if (dashArray[1] === 0) { + // Regardless of the dash value, the space value is zero, meaning + // we're actually drawing a solid stroke, not a dashed one. We can + // make this happen by just emptying out the dash array. + dashArray = []; + } + } else { + if (dashArray[0] === 0) { + // The first dash is zero-length. We fix this by combining the first + // space (just after the first dash) with the last space and updating + // the dash offset accordingly. For example, if we had + // + // [ 0 4 3 2 5 1 ] (dash offset 0) + // + // ␣␣␣␣---␣␣-----␣ + // ⎸ + // + // we'd end up with + // + // [ 3 2 5 5 ] (dash offset -4) + // + // ---␣␣-----␣␣␣␣␣ + // ⎸ + // + // Another example where the dash array also ends with a 0: + // + // [ 0 4 3 2 5 0 ] (dash offset 0) + // + // ␣␣␣␣---␣␣----- + // ⎸ + // + // we'd end up with + // + // [ 3 2 5 4 ] (dash offset -4) + // + // ---␣␣-----␣␣␣␣ + // ⎸ + dashOffset -= dashArray[1]; + dashArray[dashArray.length - 1] += dashArray[1]; + dashArray = dashArray.slice(2); + } + if (dashArray[dashArray.length - 1] === 0) { + // The last space is zero-length. We fix this by combining the last dash + // (just before the last space) with the first dash and updating the + // dash offset accordingly. For example, if we had + // + // [ 1 4 3 2 5 0 ] (dash offset 0) + // + // -␣␣␣␣---␣␣----- + // ⎸ + // + // we'd end up with + // + // [ 6 4 3 2 ] (dash offset 5) + // + // ------␣␣␣␣---␣␣ + // ⎸ + // + dashOffset += dashArray[dashArray.length - 2]; + dashArray[0] += dashArray[dashArray.length - 2]; + dashArray = dashArray.slice(0, -2); + } + } + + // Ensure the dash offset is non-negative (because of crbug.com/660850). + // First compute the total length of the dash array so we can add it to + // dash offset until dash offset is non-negative. + let length = 0; + for (let i = 0; i < dashArray.length; i++) { + length += dashArray[i]; + } + if (length > 0) { + while (dashOffset < 0) { + dashOffset += length; + } + } + doc.dash(dashArray, { + phase: dashOffset + }); + } + function docInsertLink(x, y, w, h, url) { + let ref = doc.ref({ + Type: 'Annot', + Subtype: 'Link', + Rect: [x, y, w, h], + Border: [0, 0, 0], + A: { + S: 'URI', + URI: new String(url) + } + }); + ref.end(); + links.push(ref); + } + function parseXml(xml) { + let SvgNode = function (tag, type, value, error) { + this.error = error; + this.nodeName = tag; + this.nodeValue = value; + this.nodeType = type; + this.attributes = Object.create(null); + this.childNodes = []; + this.parentNode = null; + this.id = ''; + this.textContent = ''; + this.classList = []; + }; + SvgNode.prototype.getAttribute = function (attr) { + return this.attributes[attr] != null ? this.attributes[attr] : null; + }; + SvgNode.prototype.getElementById = function (id) { + let result = null; + (function recursive(node) { + if (result) { + return; + } + if (node.nodeType === 1) { + if (node.id === id) { + result = node; + } + for (let i = 0; i < node.childNodes.length; i++) { + recursive(node.childNodes[i]); + } + } + })(this); + return result; + }; + SvgNode.prototype.getElementsByTagName = function (tag) { + let result = []; + (function recursive(node) { + if (node.nodeType === 1) { + if (node.nodeName === tag) { + result.push(node); + } + for (let i = 0; i < node.childNodes.length; i++) { + recursive(node.childNodes[i]); + } + } + })(this); + return result; + }; + let parser = new StringParser(xml.trim()), + result, + child, + error = false; + let recursive = function () { + let temp, child; + if (temp = parser.match(/^<([\w:.-]+)\s*/, true)) { + // Opening tag + let node = new SvgNode(temp[1], 1, null, error); + while (temp = parser.match(/^([\w:.-]+)(?:\s*=\s*"([^"]*)"|\s*=\s*'([^']*)')?\s*/, true)) { + // Attribute + let attr = temp[1], + value = decodeEntities(temp[2] || temp[3] || ''); + if (!node.attributes[attr]) { + node.attributes[attr] = value; + if (attr === 'id') { + node.id = value; + } + if (attr === 'class') { + node.classList = value.split(' '); + } + } else { + warningCallback('parseXml: duplicate attribute "' + attr + '"'); + error = true; + } + } + if (parser.match(/^>/)) { + // End of opening tag + while (child = recursive()) { + node.childNodes.push(child); + child.parentNode = node; + node.textContent += child.nodeType === 3 || child.nodeType === 4 ? child.nodeValue : child.textContent; + } + if (temp = parser.match(/^<\/([\w:.-]+)\s*>/, true)) { + // Closing tag + if (temp[1] === node.nodeName) { + return node; + } else { + warningCallback('parseXml: tag not matching, opening "' + node.nodeName + '" & closing "' + temp[1] + '"'); + error = true; + return node; + } + } else { + warningCallback('parseXml: tag not matching, opening "' + node.nodeName + '" & not closing'); + error = true; + return node; + } + } else if (parser.match(/^\/>/)) { + // Self-closing tag + return node; + } else { + warningCallback('parseXml: tag could not be parsed "' + node.nodeName + '"'); + error = true; + } + } else if (temp = parser.match(/^/)) { + // Comment + return new SvgNode(null, 8, temp, error); + } else if (temp = parser.match(/^<\?[\s\S]*?\?>/)) { + // Processing instructions + return new SvgNode(null, 7, temp, error); + } else if (temp = parser.match(/^/)) { + // Doctype + return new SvgNode(null, 10, temp, error); + } else if (temp = parser.match(/^/, true)) { + // Cdata node + return new SvgNode('#cdata-section', 4, temp[1], error); + } else if (temp = parser.match(/^([^<]+)/, true)) { + // Text node + return new SvgNode('#text', 3, decodeEntities(temp[1]), error); + } + }; + while (child = recursive()) { + if (child.nodeType === 1 && !result) { + result = child; + } else if (child.nodeType === 1 || child.nodeType === 3 && child.nodeValue.trim() !== '') { + warningCallback('parseXml: data after document end has been discarded'); + } + } + if (parser.matchAll()) { + warningCallback('parseXml: parsing error'); + } + return result; + } + ; + function decodeEntities(str) { + return str.replace(/&(?:#([0-9]+)|#[xX]([0-9A-Fa-f]+)|([0-9A-Za-z]+));/g, function (mt, m0, m1, m2) { + if (m0) { + return String.fromCharCode(parseInt(m0, 10)); + } else if (m1) { + return String.fromCharCode(parseInt(m1, 16)); + } else if (m2 && Entities[m2]) { + return String.fromCharCode(Entities[m2]); + } else { + return mt; + } + }); + } + function parseColor(raw) { + let temp, result; + raw = (raw || '').trim(); + if (temp = NamedColors[raw]) { + result = [temp.slice(), 1]; + } else if (temp = raw.match(/^cmyk\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) { + temp[1] = parseInt(temp[1]); + temp[2] = parseInt(temp[2]); + temp[3] = parseInt(temp[3]); + temp[4] = parseFloat(temp[4]); + if (temp[1] <= 100 && temp[2] <= 100 && temp[3] <= 100 && temp[4] <= 100) { + result = [temp.slice(1, 5), 1]; + } + } else if (temp = raw.match(/^rgba\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) { + temp[1] = parseInt(temp[1]); + temp[2] = parseInt(temp[2]); + temp[3] = parseInt(temp[3]); + temp[4] = parseFloat(temp[4]); + if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256 && temp[4] <= 1) { + result = [temp.slice(1, 4), temp[4]]; + } + } else if (temp = raw.match(/^rgb\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*\)$/i)) { + temp[1] = parseInt(temp[1]); + temp[2] = parseInt(temp[2]); + temp[3] = parseInt(temp[3]); + if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256) { + result = [temp.slice(1, 4), 1]; + } + } else if (temp = raw.match(/^rgb\(\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*,\s*([0-9.]+)%\s*\)$/i)) { + temp[1] = 2.55 * parseFloat(temp[1]); + temp[2] = 2.55 * parseFloat(temp[2]); + temp[3] = 2.55 * parseFloat(temp[3]); + if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256) { + result = [temp.slice(1, 4), 1]; + } + } else if (temp = raw.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i)) { + result = [[parseInt(temp[1], 16), parseInt(temp[2], 16), parseInt(temp[3], 16)], 1]; + } else if (temp = raw.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])$/i)) { + result = [[0x11 * parseInt(temp[1], 16), 0x11 * parseInt(temp[2], 16), 0x11 * parseInt(temp[3], 16)], 1]; + } + return colorCallback ? colorCallback(result, raw) : result; + } + function opacityToColor(color, opacity, isMask) { + let newColor = color[0].slice(), + newOpacity = color[1] * opacity; + if (isMask) { + for (let i = 0; i < color.length; i++) { + newColor[i] *= newOpacity; + } + return [newColor, 1]; + } else { + return [newColor, newOpacity]; + } + } + function multiplyMatrix() { + function multiply(a, b) { + return [a[0] * b[0] + a[2] * b[1], a[1] * b[0] + a[3] * b[1], a[0] * b[2] + a[2] * b[3], a[1] * b[2] + a[3] * b[3], a[0] * b[4] + a[2] * b[5] + a[4], a[1] * b[4] + a[3] * b[5] + a[5]]; + } + let result = arguments[0]; + for (let i = 1; i < arguments.length; i++) { + result = multiply(result, arguments[i]); + } + return result; + } + function transformPoint(p, m) { + return [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]]; + } + function getGlobalMatrix() { + let ctm = doc._ctm; + for (let i = groupStack.length - 1; i >= 0; i--) { + ctm = multiplyMatrix(groupStack[i].savedMatrix, ctm); + } + return ctm; + } + function getPageBBox() { + return new SvgShape().M(0, 0).L(doc.page.width, 0).L(doc.page.width, doc.page.height).L(0, doc.page.height).transform(inverseMatrix(getGlobalMatrix())).getBoundingBox(); + } + function getPageScale() { + const bbox = getPageBBox(); + const width = doc.page.width; + return width / bbox[2]; + } + function inverseMatrix(m) { + let dt = m[0] * m[3] - m[1] * m[2]; + return [m[3] / dt, -m[1] / dt, -m[2] / dt, m[0] / dt, (m[2] * m[5] - m[3] * m[4]) / dt, (m[1] * m[4] - m[0] * m[5]) / dt]; + } + function validateMatrix(m) { + let m0 = validateNumber(m[0]), + m1 = validateNumber(m[1]), + m2 = validateNumber(m[2]), + m3 = validateNumber(m[3]), + m4 = validateNumber(m[4]), + m5 = validateNumber(m[5]); + if (isNotEqual(m0 * m3 - m1 * m2, 0)) { + return [m0, m1, m2, m3, m4, m5]; + } + } + function solveEquation(curve) { + let a = curve[2] || 0, + b = curve[1] || 0, + c = curve[0] || 0; + if (isEqual(a, 0) && isEqual(b, 0)) { + return []; + } else if (isEqual(a, 0)) { + return [-c / b]; + } else { + let d = b * b - 4 * a * c; + if (isNotEqual(d, 0) && d > 0) { + return [(-b + Math.sqrt(d)) / (2 * a), (-b - Math.sqrt(d)) / (2 * a)]; + } else if (isEqual(d, 0)) { + return [-b / (2 * a)]; + } else { + return []; + } + } + } + function getCurveValue(t, curve) { + return (curve[0] || 0) + (curve[1] || 0) * t + (curve[2] || 0) * t * t + (curve[3] || 0) * t * t * t; + } + function isEqual(number, ref) { + return Math.abs(number - ref) < 1e-10; + } + function isNotEqual(number, ref) { + return Math.abs(number - ref) >= 1e-10; + } + function validateNumber(n) { + return n > -1e21 && n < 1e21 ? Math.round(n * 1e6) / 1e6 : 0; + } + function isArrayLike(v) { + return typeof v === 'object' && v !== null && typeof v.length === 'number'; + } + function parseTranform(v) { + let parser = new StringParser((v || '').trim()), + result = [1, 0, 0, 1, 0, 0], + temp; + while (temp = parser.match(/^([A-Za-z]+)\s*[(]([^(]+)[)]/, true)) { + let func = temp[1], + nums = [], + parser2 = new StringParser(temp[2].trim()), + temp2; + while (temp2 = parser2.matchNumber()) { + nums.push(Number(temp2)); + parser2.matchSeparator(); + } + if (func === 'matrix' && nums.length === 6) { + result = multiplyMatrix(result, [nums[0], nums[1], nums[2], nums[3], nums[4], nums[5]]); + } else if (func === 'translate' && nums.length === 2) { + result = multiplyMatrix(result, [1, 0, 0, 1, nums[0], nums[1]]); + } else if (func === 'translate' && nums.length === 1) { + result = multiplyMatrix(result, [1, 0, 0, 1, nums[0], 0]); + } else if (func === 'scale' && nums.length === 2) { + result = multiplyMatrix(result, [nums[0], 0, 0, nums[1], 0, 0]); + } else if (func === 'scale' && nums.length === 1) { + result = multiplyMatrix(result, [nums[0], 0, 0, nums[0], 0, 0]); + } else if (func === 'rotate' && nums.length === 3) { + let a = nums[0] * Math.PI / 180; + result = multiplyMatrix(result, [1, 0, 0, 1, nums[1], nums[2]], [Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0], [1, 0, 0, 1, -nums[1], -nums[2]]); + } else if (func === 'rotate' && nums.length === 1) { + let a = nums[0] * Math.PI / 180; + result = multiplyMatrix(result, [Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0]); + } else if (func === 'skewX' && nums.length === 1) { + let a = nums[0] * Math.PI / 180; + result = multiplyMatrix(result, [1, 0, Math.tan(a), 1, 0, 0]); + } else if (func === 'skewY' && nums.length === 1) { + let a = nums[0] * Math.PI / 180; + result = multiplyMatrix(result, [1, Math.tan(a), 0, 1, 0, 0]); + } else { + return; + } + parser.matchSeparator(); + } + if (parser.matchAll()) { + return; + } + return result; + } + function parseAspectRatio(aspectRatio, availWidth, availHeight, elemWidth, elemHeight, initAlign) { + let temp = (aspectRatio || '').trim().match(/^(none)$|^x(Min|Mid|Max)Y(Min|Mid|Max)(?:\s+(meet|slice))?$/) || [], + ratioType = temp[1] || temp[4] || 'meet', + xAlign = temp[2] || 'Mid', + yAlign = temp[3] || 'Mid', + scaleX = availWidth / elemWidth, + scaleY = availHeight / elemHeight, + dx = { + 'Min': 0, + 'Mid': 0.5, + 'Max': 1 + }[xAlign] - (initAlign || 0), + dy = { + 'Min': 0, + 'Mid': 0.5, + 'Max': 1 + }[yAlign] - (initAlign || 0); + if (ratioType === 'slice') { + scaleY = scaleX = Math.max(scaleX, scaleY); + } else if (ratioType === 'meet') { + scaleY = scaleX = Math.min(scaleX, scaleY); + } + return [scaleX, 0, 0, scaleY, dx * (availWidth - elemWidth * scaleX), dy * (availHeight - elemHeight * scaleY)]; + } + function parseStyleAttr(v) { + let result = Object.create(null); + v = (v || '').trim().split(/;/); + for (let i = 0; i < v.length; i++) { + let key = (v[i].split(':')[0] || '').trim(), + value = (v[i].split(':')[1] || '').trim(); + if (key) { + result[key] = value; + } + } + if (result['marker']) { + if (!result['marker-start']) { + result['marker-start'] = result['marker']; + } + if (!result['marker-mid']) { + result['marker-mid'] = result['marker']; + } + if (!result['marker-end']) { + result['marker-end'] = result['marker']; + } + } + if (result['font']) { + let fontFamily = null, + fontSize = null, + fontStyle = "normal", + fontWeight = "normal", + fontVariant = "normal"; + let parts = result['font'].split(/\s+/); + for (let i = 0; i < parts.length; i++) { + switch (parts[i]) { + case "normal": + break; + case "italic": + case "oblique": + fontStyle = parts[i]; + break; + case "small-caps": + fontVariant = parts[i]; + break; + case "bold": + case "bolder": + case "lighter": + case "100": + case "200": + case "300": + case "400": + case "500": + case "600": + case "700": + case "800": + case "900": + fontWeight = parts[i]; + break; + default: + if (!fontSize) { + fontSize = parts[i].split('/')[0]; + } else { + if (!fontFamily) { + fontFamily = parts[i]; + } else { + fontFamily += ' ' + parts[i]; + } + } + break; + } + } + if (!result['font-style']) { + result['font-style'] = fontStyle; + } + if (!result['font-variant']) { + result['font-variant'] = fontVariant; + } + if (!result['font-weight']) { + result['font-weight'] = fontWeight; + } + if (!result['font-size']) { + result['font-size'] = fontSize; + } + if (!result['font-family']) { + result['font-family'] = fontFamily; + } + } + return result; + } + function parseSelector(v) { + let parts = v.split(/(?=[.#])/g), + ids = [], + classes = [], + tags = [], + temp; + for (let i = 0; i < parts.length; i++) { + if (temp = parts[i].match(/^[#]([_A-Za-z0-9-]+)$/)) { + ids.push(temp[1]); + } else if (temp = parts[i].match(/^[.]([_A-Za-z0-9-]+)$/)) { + classes.push(temp[1]); + } else if (temp = parts[i].match(/^([_A-Za-z0-9-]+)$/)) { + tags.push(temp[1]); + } else if (parts[i] !== '*') { + return; + } + } + return { + tags: tags, + ids: ids, + classes: classes, + specificity: ids.length * 10000 + classes.length * 100 + tags.length + }; + } + function parseStyleSheet(v) { + let parser = new StringParser(v.trim()), + rules = [], + rule; + while (rule = parser.match(/^\s*([^\{\}]*?)\s*\{([^\{\}]*?)\}/, true)) { + let selectors = rule[1].split(/\s*,\s*/g), + css = parseStyleAttr(rule[2]); + for (let i = 0; i < selectors.length; i++) { + let selector = parseSelector(selectors[i]); + if (selector) { + rules.push({ + selector: selector, + css: css + }); + } + } + } + return rules; + } + function matchesSelector(elem, selector) { + if (elem.nodeType !== 1) { + return false; + } + for (let i = 0; i < selector.tags.length; i++) { + if (selector.tags[i] !== elem.nodeName) { + return false; + } + } + for (let i = 0; i < selector.ids.length; i++) { + if (selector.ids[i] !== elem.id) { + return false; + } + } + for (let i = 0; i < selector.classes.length; i++) { + if (elem.classList.indexOf(selector.classes[i]) === -1) { + return false; + } + } + return true; + } + function getStyle(elem) { + let result = Object.create(null); + let specificities = Object.create(null); + for (let i = 0; i < styleRules.length; i++) { + let rule = styleRules[i]; + if (matchesSelector(elem, rule.selector)) { + for (let key in rule.css) { + if (!(specificities[key] > rule.selector.specificity)) { + result[key] = rule.css[key]; + specificities[key] = rule.selector.specificity; + } + } + } + } + return result; + } + function combineArrays(array1, array2) { + return array1.concat(array2.slice(array1.length)); + } + function getAscent(font, size) { + return Math.max(font.ascender, (font.bbox[3] || font.bbox.maxY) * (font.scale || 1)) * size / 1000; + } + function getDescent(font, size) { + return Math.min(font.descender, (font.bbox[1] || font.bbox.minY) * (font.scale || 1)) * size / 1000; + } + function getXHeight(font, size) { + return (font.xHeight || 0.5 * (font.ascender - font.descender)) * size / 1000; + } + function getBaseline(font, size, baseline, shift) { + let dy1, dy2; + switch (baseline) { + case 'middle': + dy1 = 0.5 * getXHeight(font, size); + break; + case 'central': + dy1 = 0.5 * (getDescent(font, size) + getAscent(font, size)); + break; + case 'after-edge': + case 'text-after-edge': + dy1 = getDescent(font, size); + break; + case 'alphabetic': + case 'auto': + case 'baseline': + dy1 = 0; + break; + case 'mathematical': + dy1 = 0.5 * getAscent(font, size); + break; + case 'hanging': + dy1 = 0.8 * getAscent(font, size); + break; + case 'before-edge': + case 'text-before-edge': + dy1 = getAscent(font, size); + break; + default: + dy1 = 0; + break; + } + switch (shift) { + case 'baseline': + dy2 = 0; + break; + case 'super': + dy2 = 0.6 * size; + break; + case 'sub': + dy2 = -0.6 * size; + break; + default: + dy2 = shift; + break; + } + return dy1 - dy2; + } + function getTextPos(font, size, text) { + let encoded = font.encode('' + text), + hex = encoded[0], + pos = encoded[1], + data = []; + for (let i = 0; i < hex.length; i++) { + let unicode = font.unicode ? font.unicode[parseInt(hex[i], 16)] : [text.charCodeAt(i)]; + data.push({ + glyph: hex[i], + unicode: unicode, + kern: pos[i].advanceWidth - pos[i].xAdvance, + width: pos[i].advanceWidth * size / 1000, + xOffset: pos[i].xOffset * size / 1000, + yOffset: pos[i].yOffset * size / 1000, + xAdvance: pos[i].xAdvance * size / 1000, + yAdvance: pos[i].yAdvance * size / 1000 + }); + } + return data; + } + function createSVGElement(obj, inherits) { + switch (obj.nodeName) { + case 'use': + return new SvgElemUse(obj, inherits); + case 'symbol': + return new SvgElemSymbol(obj, inherits); + case 'g': + return new SvgElemGroup(obj, inherits); + case 'a': + return new SvgElemLink(obj, inherits); + case 'svg': + return new SvgElemSvg(obj, inherits); + case 'image': + return new SVGElemImage(obj, inherits); + case 'rect': + return new SvgElemRect(obj, inherits); + case 'circle': + return new SvgElemCircle(obj, inherits); + case 'ellipse': + return new SvgElemEllipse(obj, inherits); + case 'line': + return new SvgElemLine(obj, inherits); + case 'polyline': + return new SvgElemPolyline(obj, inherits); + case 'polygon': + return new SvgElemPolygon(obj, inherits); + case 'path': + return new SvgElemPath(obj, inherits); + case 'text': + return new SvgElemText(obj, inherits); + case 'tspan': + return new SvgElemTspan(obj, inherits); + case 'textPath': + return new SvgElemTextPath(obj, inherits); + case '#text': + case '#cdata-section': + return new SvgElemTextNode(obj, inherits); + default: + return new SvgElem(obj, inherits); + } + } + var StringParser = function (str) { + this.match = function (exp, all) { + let temp = str.match(exp); + if (!temp || temp.index !== 0) { + return; + } + str = str.substring(temp[0].length); + return all ? temp : temp[0]; + }; + this.matchSeparator = function () { + return this.match(/^(?:\s*,\s*|\s*|)/); + }; + this.matchSpace = function () { + return this.match(/^(?:\s*)/); + }; + this.matchLengthUnit = function () { + return this.match(/^(?:px|pt|cm|mm|in|pc|em|ex|%|)/); + }; + this.matchNumber = function () { + return this.match(/^(?:[-+]?(?:[0-9]+[.][0-9]+|[0-9]+[.]|[.][0-9]+|[0-9]+)(?:[eE][-+]?[0-9]+)?)/); + }; + this.matchAll = function () { + return this.match(/^[\s\S]+/); + }; + }; + var BezierSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) { + let divisions = 6 * precision; + let equationX = [p1x, -3 * p1x + 3 * c1x, 3 * p1x - 6 * c1x + 3 * c2x, -p1x + 3 * c1x - 3 * c2x + p2x]; + let equationY = [p1y, -3 * p1y + 3 * c1y, 3 * p1y - 6 * c1y + 3 * c2y, -p1y + 3 * c1y - 3 * c2y + p2y]; + let derivativeX = [-3 * p1x + 3 * c1x, 6 * p1x - 12 * c1x + 6 * c2x, -3 * p1x + 9 * c1x - 9 * c2x + 3 * p2x]; + let derivativeY = [-3 * p1y + 3 * c1y, 6 * p1y - 12 * c1y + 6 * c2y, -3 * p1y + 9 * c1y - 9 * c2y + 3 * p2y]; + let lengthMap = [0]; + for (let i = 1; i <= divisions; i++) { + let t = (i - 0.5) / divisions; + let dx = getCurveValue(t, derivativeX) / divisions, + dy = getCurveValue(t, derivativeY) / divisions, + l = Math.sqrt(dx * dx + dy * dy); + lengthMap[i] = lengthMap[i - 1] + l; + } + this.totalLength = lengthMap[divisions]; + this.startPoint = [p1x, p1y, isEqual(p1x, c1x) && isEqual(p1y, c1y) ? Math.atan2(c2y - c1y, c2x - c1x) : Math.atan2(c1y - p1y, c1x - p1x)]; + this.endPoint = [p2x, p2y, isEqual(c2x, p2x) && isEqual(c2y, p2y) ? Math.atan2(c2y - c1y, c2x - c1x) : Math.atan2(p2y - c2y, p2x - c2x)]; + this.getBoundingBox = function () { + let temp; + let minX = getCurveValue(0, equationX), + minY = getCurveValue(0, equationY), + maxX = getCurveValue(1, equationX), + maxY = getCurveValue(1, equationY); + if (minX > maxX) { + temp = maxX; + maxX = minX; + minX = temp; + } + if (minY > maxY) { + temp = maxY; + maxY = minY; + minY = temp; + } + let rootsX = solveEquation(derivativeX); + for (let i = 0; i < rootsX.length; i++) { + if (rootsX[i] >= 0 && rootsX[i] <= 1) { + let x = getCurveValue(rootsX[i], equationX); + if (x < minX) { + minX = x; + } + if (x > maxX) { + maxX = x; + } + } + } + let rootsY = solveEquation(derivativeY); + for (let i = 0; i < rootsY.length; i++) { + if (rootsY[i] >= 0 && rootsY[i] <= 1) { + let y = getCurveValue(rootsY[i], equationY); + if (y < minY) { + minY = y; + } + if (y > maxY) { + maxY = y; + } + } + } + return [minX, minY, maxX, maxY]; + }; + this.getPointAtLength = function (l) { + if (isEqual(l, 0)) { + return this.startPoint; + } + if (isEqual(l, this.totalLength)) { + return this.endPoint; + } + if (l < 0 || l > this.totalLength) { + return; + } + for (let i = 1; i <= divisions; i++) { + let l1 = lengthMap[i - 1], + l2 = lengthMap[i]; + if (l1 <= l && l <= l2) { + let t = (i - (l2 - l) / (l2 - l1)) / divisions, + x = getCurveValue(t, equationX), + y = getCurveValue(t, equationY), + dx = getCurveValue(t, derivativeX), + dy = getCurveValue(t, derivativeY); + return [x, y, Math.atan2(dy, dx)]; + } + } + }; + }; + var LineSegment = function (p1x, p1y, p2x, p2y) { + this.totalLength = Math.sqrt((p2x - p1x) * (p2x - p1x) + (p2y - p1y) * (p2y - p1y)); + this.startPoint = [p1x, p1y, Math.atan2(p2y - p1y, p2x - p1x)]; + this.endPoint = [p2x, p2y, Math.atan2(p2y - p1y, p2x - p1x)]; + this.getBoundingBox = function () { + return [Math.min(this.startPoint[0], this.endPoint[0]), Math.min(this.startPoint[1], this.endPoint[1]), Math.max(this.startPoint[0], this.endPoint[0]), Math.max(this.startPoint[1], this.endPoint[1])]; + }; + this.getPointAtLength = function (l) { + if (l >= 0 && l <= this.totalLength) { + let r = l / this.totalLength || 0, + x = this.startPoint[0] + r * (this.endPoint[0] - this.startPoint[0]), + y = this.startPoint[1] + r * (this.endPoint[1] - this.startPoint[1]); + return [x, y, this.startPoint[2]]; + } + }; + }; + var SvgShape = function () { + this.pathCommands = []; + this.pathSegments = []; + this.startPoint = null; + this.endPoint = null; + this.totalLength = 0; + let startX = 0, + startY = 0, + currX = 0, + currY = 0, + lastCom, + lastCtrlX, + lastCtrlY; + this.move = function (x, y) { + startX = currX = x; + startY = currY = y; + return null; + }; + this.line = function (x, y) { + let segment = new LineSegment(currX, currY, x, y); + currX = x; + currY = y; + return segment; + }; + this.curve = function (c1x, c1y, c2x, c2y, x, y) { + let segment = new BezierSegment(currX, currY, c1x, c1y, c2x, c2y, x, y); + currX = x; + currY = y; + return segment; + }; + this.close = function () { + let segment = new LineSegment(currX, currY, startX, startY); + currX = startX; + currY = startY; + return segment; + }; + this.addCommand = function (data) { + this.pathCommands.push(data); + let segment = this[data[0]].apply(this, data.slice(3)); + if (segment) { + segment.hasStart = data[1]; + segment.hasEnd = data[2]; + this.startPoint = this.startPoint || segment.startPoint; + this.endPoint = segment.endPoint; + this.pathSegments.push(segment); + this.totalLength += segment.totalLength; + } + }; + this.M = function (x, y) { + this.addCommand(['move', true, true, x, y]); + lastCom = 'M'; + return this; + }; + this.m = function (x, y) { + return this.M(currX + x, currY + y); + }; + this.Z = this.z = function () { + this.addCommand(['close', true, true]); + lastCom = 'Z'; + return this; + }; + this.L = function (x, y) { + this.addCommand(['line', true, true, x, y]); + lastCom = 'L'; + return this; + }; + this.l = function (x, y) { + return this.L(currX + x, currY + y); + }; + this.H = function (x) { + return this.L(x, currY); + }; + this.h = function (x) { + return this.L(currX + x, currY); + }; + this.V = function (y) { + return this.L(currX, y); + }; + this.v = function (y) { + return this.L(currX, currY + y); + }; + this.C = function (c1x, c1y, c2x, c2y, x, y) { + this.addCommand(['curve', true, true, c1x, c1y, c2x, c2y, x, y]); + lastCom = 'C'; + lastCtrlX = c2x; + lastCtrlY = c2y; + return this; + }; + this.c = function (c1x, c1y, c2x, c2y, x, y) { + return this.C(currX + c1x, currY + c1y, currX + c2x, currY + c2y, currX + x, currY + y); + }; + this.S = function (c1x, c1y, x, y) { + return this.C(currX + (lastCom === 'C' ? currX - lastCtrlX : 0), currY + (lastCom === 'C' ? currY - lastCtrlY : 0), c1x, c1y, x, y); + }; + this.s = function (c1x, c1y, x, y) { + return this.C(currX + (lastCom === 'C' ? currX - lastCtrlX : 0), currY + (lastCom === 'C' ? currY - lastCtrlY : 0), currX + c1x, currY + c1y, currX + x, currY + y); + }; + this.Q = function (cx, cy, x, y) { + let c1x = currX + 2 / 3 * (cx - currX), + c1y = currY + 2 / 3 * (cy - currY), + c2x = x + 2 / 3 * (cx - x), + c2y = y + 2 / 3 * (cy - y); + this.addCommand(['curve', true, true, c1x, c1y, c2x, c2y, x, y]); + lastCom = 'Q'; + lastCtrlX = cx; + lastCtrlY = cy; + return this; + }; + this.q = function (c1x, c1y, x, y) { + return this.Q(currX + c1x, currY + c1y, currX + x, currY + y); + }; + this.T = function (x, y) { + return this.Q(currX + (lastCom === 'Q' ? currX - lastCtrlX : 0), currY + (lastCom === 'Q' ? currY - lastCtrlY : 0), x, y); + }; + this.t = function (x, y) { + return this.Q(currX + (lastCom === 'Q' ? currX - lastCtrlX : 0), currY + (lastCom === 'Q' ? currY - lastCtrlY : 0), currX + x, currY + y); + }; + this.A = function (rx, ry, fi, fa, fs, x, y) { + if (isEqual(rx, 0) || isEqual(ry, 0)) { + this.addCommand(['line', true, true, x, y]); + } else { + fi = fi * (Math.PI / 180); + rx = Math.abs(rx); + ry = Math.abs(ry); + fa = 1 * !!fa; + fs = 1 * !!fs; + let x1 = Math.cos(fi) * (currX - x) / 2 + Math.sin(fi) * (currY - y) / 2, + y1 = Math.cos(fi) * (currY - y) / 2 - Math.sin(fi) * (currX - x) / 2, + lambda = x1 * x1 / (rx * rx) + y1 * y1 / (ry * ry); + if (lambda > 1) { + rx *= Math.sqrt(lambda); + ry *= Math.sqrt(lambda); + } + let r = Math.sqrt(Math.max(0, rx * rx * ry * ry - rx * rx * y1 * y1 - ry * ry * x1 * x1) / (rx * rx * y1 * y1 + ry * ry * x1 * x1)), + x2 = (fa === fs ? -1 : 1) * r * rx * y1 / ry, + y2 = (fa === fs ? 1 : -1) * r * ry * x1 / rx; + let cx = Math.cos(fi) * x2 - Math.sin(fi) * y2 + (currX + x) / 2, + cy = Math.sin(fi) * x2 + Math.cos(fi) * y2 + (currY + y) / 2, + th1 = Math.atan2((y1 - y2) / ry, (x1 - x2) / rx), + th2 = Math.atan2((-y1 - y2) / ry, (-x1 - x2) / rx); + if (fs === 0 && th2 - th1 > 0) { + th2 -= 2 * Math.PI; + } else if (fs === 1 && th2 - th1 < 0) { + th2 += 2 * Math.PI; + } + let segms = Math.ceil(Math.abs(th2 - th1) / (Math.PI / precision)); + for (let i = 0; i < segms; i++) { + let th3 = th1 + i * (th2 - th1) / segms, + th4 = th1 + (i + 1) * (th2 - th1) / segms, + t = 4 / 3 * Math.tan((th4 - th3) / 4); + let c1x = cx + Math.cos(fi) * rx * (Math.cos(th3) - t * Math.sin(th3)) - Math.sin(fi) * ry * (Math.sin(th3) + t * Math.cos(th3)), + c1y = cy + Math.sin(fi) * rx * (Math.cos(th3) - t * Math.sin(th3)) + Math.cos(fi) * ry * (Math.sin(th3) + t * Math.cos(th3)), + c2x = cx + Math.cos(fi) * rx * (Math.cos(th4) + t * Math.sin(th4)) - Math.sin(fi) * ry * (Math.sin(th4) - t * Math.cos(th4)), + c2y = cy + Math.sin(fi) * rx * (Math.cos(th4) + t * Math.sin(th4)) + Math.cos(fi) * ry * (Math.sin(th4) - t * Math.cos(th4)), + endX = cx + Math.cos(fi) * rx * Math.cos(th4) - Math.sin(fi) * ry * Math.sin(th4), + endY = cy + Math.sin(fi) * rx * Math.cos(th4) + Math.cos(fi) * ry * Math.sin(th4); + this.addCommand(['curve', i === 0, i === segms - 1, c1x, c1y, c2x, c2y, endX, endY]); + } + } + lastCom = 'A'; + return this; + }; + this.a = function (rx, ry, fi, fa, fs, x, y) { + return this.A(rx, ry, fi, fa, fs, currX + x, currY + y); + }; + this.path = function (d) { + let command, + value, + temp, + parser = new StringParser((d || '').trim()); + while (command = parser.match(/^[astvzqmhlcASTVZQMHLC]/)) { + parser.matchSeparator(); + let values = []; + while (value = PathFlags[command + values.length] ? parser.match(/^[01]/) : parser.matchNumber()) { + parser.matchSeparator(); + if (values.length === PathArguments[command]) { + this[command].apply(this, values); + values = []; + if (command === 'M') { + command = 'L'; + } else if (command === 'm') { + command = 'l'; + } + } + values.push(Number(value)); + } + if (values.length === PathArguments[command]) { + this[command].apply(this, values); + } else { + warningCallback('SvgPath: command ' + command + ' with ' + values.length + ' numbers'); + return; + } + } + if (temp = parser.matchAll()) { + warningCallback('SvgPath: unexpected string ' + temp); + } + return this; + }; + this.getBoundingBox = function () { + let bbox = [Infinity, Infinity, -Infinity, -Infinity]; + function addBounds(bbox1) { + if (bbox1[0] < bbox[0]) { + bbox[0] = bbox1[0]; + } + if (bbox1[2] > bbox[2]) { + bbox[2] = bbox1[2]; + } + if (bbox1[1] < bbox[1]) { + bbox[1] = bbox1[1]; + } + if (bbox1[3] > bbox[3]) { + bbox[3] = bbox1[3]; + } + } + for (let i = 0; i < this.pathSegments.length; i++) { + addBounds(this.pathSegments[i].getBoundingBox()); + } + if (bbox[0] === Infinity) { + bbox[0] = 0; + } + if (bbox[1] === Infinity) { + bbox[1] = 0; + } + if (bbox[2] === -Infinity) { + bbox[2] = 0; + } + if (bbox[3] === -Infinity) { + bbox[3] = 0; + } + return bbox; + }; + this.getPointAtLength = function (l) { + if (l >= 0 && l <= this.totalLength) { + let temp; + for (let i = 0; i < this.pathSegments.length; i++) { + if (temp = this.pathSegments[i].getPointAtLength(l)) { + return temp; + } + l -= this.pathSegments[i].totalLength; + } + return this.endPoint; + } + }; + this.transform = function (m) { + this.pathSegments = []; + this.startPoint = null; + this.endPoint = null; + this.totalLength = 0; + for (let i = 0; i < this.pathCommands.length; i++) { + let data = this.pathCommands.shift(); + for (let j = 3; j < data.length; j += 2) { + let p = transformPoint([data[j], data[j + 1]], m); + data[j] = p[0]; + data[j + 1] = p[1]; + } + this.addCommand(data); + } + return this; + }; + this.mergeShape = function (shape) { + for (let i = 0; i < shape.pathCommands.length; i++) { + this.addCommand(shape.pathCommands[i].slice()); + } + return this; + }; + this.clone = function () { + return new SvgShape().mergeShape(this); + }; + this.insertInDocument = function () { + for (let i = 0; i < this.pathCommands.length; i++) { + let command = this.pathCommands[i][0], + values = this.pathCommands[i].slice(3); + switch (command) { + case 'move': + doc.moveTo(values[0], values[1]); + break; + case 'line': + doc.lineTo(values[0], values[1]); + break; + case 'curve': + doc.bezierCurveTo(values[0], values[1], values[2], values[3], values[4], values[5]); + break; + case 'close': + doc.closePath(); + break; + } + } + }; + this.getSubPaths = function () { + let subPaths = [], + shape = new SvgShape(); + for (let i = 0; i < this.pathCommands.length; i++) { + let data = this.pathCommands[i], + command = this.pathCommands[i][0]; + if (command === 'move' && i !== 0) { + subPaths.push(shape); + shape = new SvgShape(); + } + shape.addCommand(data); + } + subPaths.push(shape); + return subPaths; + }; + this.getMarkers = function () { + let markers = [], + subPaths = this.getSubPaths(); + for (let i = 0; i < subPaths.length; i++) { + let subPath = subPaths[i], + subPathMarkers = []; + for (let j = 0; j < subPath.pathSegments.length; j++) { + let segment = subPath.pathSegments[j]; + if (isNotEqual(segment.totalLength, 0) || j === 0 || j === subPath.pathSegments.length - 1) { + if (segment.hasStart) { + let startMarker = segment.getPointAtLength(0), + prevEndMarker = subPathMarkers.pop(); + if (prevEndMarker) { + startMarker[2] = 0.5 * (prevEndMarker[2] + startMarker[2]); + } + subPathMarkers.push(startMarker); + } + if (segment.hasEnd) { + let endMarker = segment.getPointAtLength(segment.totalLength); + subPathMarkers.push(endMarker); + } + } + } + markers = markers.concat(subPathMarkers); + } + return markers; + }; + }; + var SvgElem = function (obj, inherits) { + let styleCache = Object.create(null); + let childrenCache = null; + this.name = obj.nodeName; + this.isOuterElement = obj === svg || !obj.parentNode; + this.inherits = inherits || (!this.isOuterElement ? createSVGElement(obj.parentNode, null) : null); + this.stack = this.inherits ? this.inherits.stack.concat(obj) : [obj]; + this.style = parseStyleAttr(typeof obj.getAttribute === 'function' && obj.getAttribute('style')); + this.css = useCSS ? getComputedStyle(obj) : getStyle(obj); + this.allowedChildren = []; + this.attr = function (key) { + if (typeof obj.getAttribute === 'function') { + return obj.getAttribute(key); + } + }; + this.resolveUrl = function (value) { + let temp = (value || '').match(/^\s*(?:url\("(.*)#(.*)"\)|url\('(.*)#(.*)'\)|url\((.*)#(.*)\)|(.*)#(.*))\s*$/) || []; + let file = temp[1] || temp[3] || temp[5] || temp[7], + id = temp[2] || temp[4] || temp[6] || temp[8]; + if (id) { + if (!file) { + let svgObj = svg.getElementById(id); + if (svgObj) { + if (this.stack.indexOf(svgObj) === -1) { + return svgObj; + } else { + warningCallback('SVGtoPDF: loop of circular references for id "' + id + '"'); + return; + } + } + } + if (documentCallback) { + let svgs = documentCache[file]; + if (!svgs) { + svgs = documentCallback(file); + if (!isArrayLike(svgs)) { + svgs = [svgs]; + } + for (let i = 0; i < svgs.length; i++) { + if (typeof svgs[i] === 'string') { + svgs[i] = parseXml(svgs[i]); + } + } + documentCache[file] = svgs; + } + for (let i = 0; i < svgs.length; i++) { + let svgObj = svgs[i].getElementById(id); + if (svgObj) { + if (this.stack.indexOf(svgObj) === -1) { + return svgObj; + } else { + warningCallback('SVGtoPDF: loop of circular references for id "' + file + '#' + id + '"'); + return; + } + } + } + } + } + }; + this.computeUnits = function (value, unit, percent, isFontSize) { + if (unit === '%') { + return parseFloat(value) / 100 * (isFontSize || percent != null ? percent : this.getViewport()); + } else if (unit === 'ex' || unit === 'em') { + return value * { + 'em': 1, + 'ex': 0.5 + }[unit] * (isFontSize ? percent : this.get('font-size')); + } else { + return value * { + '': 1, + 'px': 1, + 'pt': 96 / 72, + 'cm': 96 / 2.54, + 'mm': 96 / 25.4, + 'in': 96, + 'pc': 96 / 6 + }[unit]; + } + }; + this.computeLength = function (value, percent, initial, isFontSize) { + let parser = new StringParser((value || '').trim()), + temp1, + temp2; + if (typeof (temp1 = parser.matchNumber()) === 'string' && typeof (temp2 = parser.matchLengthUnit()) === 'string' && !parser.matchAll()) { + return this.computeUnits(temp1, temp2, percent, isFontSize); + } + return initial; + }; + this.computeLengthList = function (value, percent, strict) { + let parser = new StringParser((value || '').trim()), + result = [], + temp1, + temp2; + while (typeof (temp1 = parser.matchNumber()) === 'string' && typeof (temp2 = parser.matchLengthUnit()) === 'string') { + result.push(this.computeUnits(temp1, temp2, percent)); + parser.matchSeparator(); + } + if (strict && parser.matchAll()) { + return; + } + return result; + }; + this.getLength = function (key, percent, initial) { + return this.computeLength(this.attr(key), percent, initial); + }; + this.getLengthList = function (key, percent) { + return this.computeLengthList(this.attr(key), percent); + }; + this.getUrl = function (key) { + return this.resolveUrl(this.attr(key)); + }; + this.getNumberList = function (key) { + let parser = new StringParser((this.attr(key) || '').trim()), + result = [], + temp; + while (temp = parser.matchNumber()) { + result.push(Number(temp)); + parser.matchSeparator(); + } + result.error = parser.matchAll(); + return result; + }; + this.getViewbox = function (key, initial) { + let viewBox = this.getNumberList(key); + if (viewBox.length === 4 && viewBox[2] >= 0 && viewBox[3] >= 0) { + return viewBox; + } + return initial; + }; + this.getPercent = function (key, initial) { + let value = this.attr(key); + let parser = new StringParser((value || '').trim()), + temp1, + temp2; + let number = parser.matchNumber(); + if (!number) { + return initial; + } + if (parser.match('%')) { + number *= 0.01; + } + if (parser.matchAll()) { + return initial; + } + return Math.max(0, Math.min(1, number)); + }; + this.chooseValue = function (args) { + for (let i = 0; i < arguments.length; i++) { + if (arguments[i] != null && arguments[i] === arguments[i]) { + return arguments[i]; + } + } + return arguments[arguments.length - 1]; + }; + this.get = function (key) { + if (styleCache[key] !== undefined) { + return styleCache[key]; + } + let keyInfo = Properties[key] || {}, + value, + result; + for (let i = 0; i < 3; i++) { + switch (i) { + case 0: + if (key !== 'transform') { + // the CSS transform behaves strangely + value = this.css[keyInfo.css || key]; + } + break; + case 1: + value = this.style[key]; + break; + case 2: + value = this.attr(key); + break; + } + if (value === 'inherit') { + result = this.inherits ? this.inherits.get(key) : keyInfo.initial; + if (result != null) { + return styleCache[key] = result; + } + } + if (keyInfo.values != null) { + result = keyInfo.values[value]; + if (result != null) { + return styleCache[key] = result; + } + } + if (value != null) { + let parsed; + switch (key) { + case 'font-size': + result = this.computeLength(value, this.inherits ? this.inherits.get(key) : keyInfo.initial, undefined, true); + break; + case 'baseline-shift': + result = this.computeLength(value, this.get('font-size')); + break; + case 'font-family': + result = value || undefined; + break; + case 'opacity': + case 'stroke-opacity': + case 'fill-opacity': + case 'stop-opacity': + parsed = parseFloat(value); + if (!isNaN(parsed)) { + result = Math.max(0, Math.min(1, parsed)); + } + break; + case 'transform': + result = parseTranform(value); + break; + case 'stroke-dasharray': + if (value === 'none') { + result = []; + } else if (parsed = this.computeLengthList(value, this.getViewport(), true)) { + let sum = 0, + error = false; + for (let j = 0; j < parsed.length; j++) { + if (parsed[j] < 0) { + error = true; + } + sum += parsed[j]; + } + if (!error) { + if (parsed.length % 2 === 1) { + parsed = parsed.concat(parsed); + } + result = sum === 0 ? [] : parsed; + } + } + break; + case 'color': + if (value === 'none' || value === 'transparent') { + result = 'none'; + } else { + result = parseColor(value); + } + break; + case 'fill': + case 'stroke': + if (value === 'none' || value === 'transparent') { + result = 'none'; + } else if (value === 'currentColor') { + result = this.get('color'); + } else if (parsed = parseColor(value)) { + return parsed; + } else if (parsed = (value || '').split(' ')) { + let object = this.resolveUrl(parsed[0]), + fallbackColor = parseColor(parsed[1]); + if (object == null) { + result = fallbackColor; + } else if (object.nodeName === 'linearGradient' || object.nodeName === 'radialGradient') { + result = new SvgElemGradient(object, null, fallbackColor); + } else if (object.nodeName === 'pattern') { + result = new SvgElemPattern(object, null, fallbackColor); + } else { + result = fallbackColor; + } + } + break; + case 'stop-color': + if (value === 'none' || value === 'transparent') { + result = 'none'; + } else if (value === 'currentColor') { + result = this.get('color'); + } else { + result = parseColor(value); + } + break; + case 'marker-start': + case 'marker-mid': + case 'marker-end': + case 'clip-path': + case 'mask': + if (value === 'none') { + result = 'none'; + } else { + result = this.resolveUrl(value); + } + break; + case 'stroke-width': + parsed = this.computeLength(value, this.getViewport()); + if (parsed != null && parsed >= 0) { + result = parsed; + } + break; + case 'stroke-miterlimit': + parsed = parseFloat(value); + if (parsed != null && parsed >= 1) { + result = parsed; + } + break; + case 'word-spacing': + case 'letter-spacing': + result = this.computeLength(value, this.getViewport()); + break; + case 'stroke-dashoffset': + result = this.computeLength(value, this.getViewport()); + break; + } + if (result != null) { + return styleCache[key] = result; + } + } + } + return styleCache[key] = keyInfo.inherit && this.inherits ? this.inherits.get(key) : keyInfo.initial; + }; + this.getChildren = function () { + if (childrenCache != null) { + return childrenCache; + } + let children = []; + for (let i = 0; i < obj.childNodes.length; i++) { + let child = obj.childNodes[i]; + if (!child.error && this.allowedChildren.indexOf(child.nodeName) !== -1) { + children.push(createSVGElement(child, this)); + } + } + return childrenCache = children; + }; + this.getParentVWidth = function () { + return this.inherits ? this.inherits.getVWidth() : viewportWidth; + }; + this.getParentVHeight = function () { + return this.inherits ? this.inherits.getVHeight() : viewportHeight; + }; + this.getParentViewport = function () { + return Math.sqrt(0.5 * this.getParentVWidth() * this.getParentVWidth() + 0.5 * this.getParentVHeight() * this.getParentVHeight()); + }; + this.getVWidth = function () { + return this.getParentVWidth(); + }; + this.getVHeight = function () { + return this.getParentVHeight(); + }; + this.getViewport = function () { + return Math.sqrt(0.5 * this.getVWidth() * this.getVWidth() + 0.5 * this.getVHeight() * this.getVHeight()); + }; + this.getBoundingBox = function () { + let shape = this.getBoundingShape(); + return shape.getBoundingBox(); + }; + }; + var SvgElemStylable = function (obj, inherits) { + SvgElem.call(this, obj, inherits); + this.transform = function () { + doc.transform.apply(doc, this.getTransformation()); + }; + this.clip = function () { + if (this.get('clip-path') !== 'none') { + let clipPath = new SvgElemClipPath(this.get('clip-path'), null); + clipPath.useMask(clipPath.attr('clipPathUnits') === 'objectBoundingBox' ? this.getBoundingBox() : null); + return true; + } + }; + this.mask = function () { + if (this.get('mask') !== 'none') { + let mask = new SvgElemMask(this.get('mask'), null); + mask.useMask(this.getBoundingBox()); + return true; + } + }; + this.getFill = function (isClip, isMask) { + let opacity = this.get('opacity'), + fill = this.get('fill'), + fillOpacity = this.get('fill-opacity'); + if (isClip) { + return DefaultColors.white; + } + if (fill !== 'none' && opacity && fillOpacity) { + if (fill instanceof SvgElemGradient || fill instanceof SvgElemPattern) { + return fill.getPaint(this.getBoundingBox(), fillOpacity * opacity, isClip, isMask); + } + return opacityToColor(fill, fillOpacity * opacity, isMask); + } + }; + this.getStroke = function (isClip, isMask) { + let opacity = this.get('opacity'), + stroke = this.get('stroke'), + strokeOpacity = this.get('stroke-opacity'); + if (isClip || isEqual(this.get('stroke-width'), 0)) { + return; + } + if (stroke !== 'none' && opacity && strokeOpacity) { + if (stroke instanceof SvgElemGradient || stroke instanceof SvgElemPattern) { + return stroke.getPaint(this.getBoundingBox(), strokeOpacity * opacity, isClip, isMask); + } + return opacityToColor(stroke, strokeOpacity * opacity, isMask); + } + }; + }; + var SvgElemHasChildren = function (obj, inherits) { + SvgElemStylable.call(this, obj, inherits); + this.allowedChildren = ['use', 'g', 'a', 'svg', 'image', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon', 'path', 'text']; + this.getBoundingShape = function () { + let shape = new SvgShape(), + children = this.getChildren(); + for (let i = 0; i < children.length; i++) { + if (children[i].get('display') !== 'none') { + if (typeof children[i].getBoundingShape === 'function') { + let childShape = children[i].getBoundingShape().clone(); + if (typeof children[i].getTransformation === 'function') { + childShape.transform(children[i].getTransformation()); + } + shape.mergeShape(childShape); + } + } + } + return shape; + }; + this.drawChildren = function (isClip, isMask) { + let children = this.getChildren(); + for (let i = 0; i < children.length; i++) { + if (children[i].get('display') !== 'none') { + if (typeof children[i].drawInDocument === 'function') { + children[i].drawInDocument(isClip, isMask); + } + } + } + }; + }; + var SvgElemContainer = function (obj, inherits) { + SvgElemHasChildren.call(this, obj, inherits); + this.drawContent = function (isClip, isMask) { + this.transform(); + let clipped = this.clip(), + masked = this.mask(), + group; + if ((this.get('opacity') < 1 || clipped || masked) && !isClip) { + group = docBeginGroup(getPageBBox()); + } + this.drawChildren(isClip, isMask); + if (group) { + docEndGroup(group); + doc.fillOpacity(this.get('opacity')); + docInsertGroup(group); + } + }; + }; + var SvgElemUse = function (obj, inherits) { + SvgElemContainer.call(this, obj, inherits); + let x = this.getLength('x', this.getVWidth(), 0), + y = this.getLength('y', this.getVHeight(), 0), + child = this.getUrl('href') || this.getUrl('xlink:href'); + if (child) { + child = createSVGElement(child, this); + } + this.getChildren = function () { + return child ? [child] : []; + }; + this.drawInDocument = function (isClip, isMask) { + doc.save(); + this.drawContent(isClip, isMask); + doc.restore(); + }; + this.getTransformation = function () { + return multiplyMatrix(this.get('transform'), [1, 0, 0, 1, x, y]); + }; + }; + var SvgElemSymbol = function (obj, inherits) { + SvgElemContainer.call(this, obj, inherits); + let width = this.getLength('width', this.getParentVWidth(), this.getParentVWidth()), + height = this.getLength('height', this.getParentVHeight(), this.getParentVHeight()); + if (inherits instanceof SvgElemUse) { + width = inherits.getLength('width', inherits.getParentVWidth(), width); + height = inherits.getLength('height', inherits.getParentVHeight(), height); + } + let aspectRatio = (this.attr('preserveAspectRatio') || '').trim(), + viewBox = this.getViewbox('viewBox', [0, 0, width, height]); + this.getVWidth = function () { + return viewBox[2]; + }; + this.getVHeight = function () { + return viewBox[3]; + }; + this.drawInDocument = function (isClip, isMask) { + doc.save(); + this.drawContent(isClip, isMask); + doc.restore(); + }; + this.getTransformation = function () { + return multiplyMatrix(parseAspectRatio(aspectRatio, width, height, viewBox[2], viewBox[3]), [1, 0, 0, 1, -viewBox[0], -viewBox[1]]); + }; + }; + var SvgElemGroup = function (obj, inherits) { + SvgElemContainer.call(this, obj, inherits); + this.drawInDocument = function (isClip, isMask) { + doc.save(); + if (this.link && !isClip && !isMask) { + this.addLink(); + } + this.drawContent(isClip, isMask); + doc.restore(); + }; + this.getTransformation = function () { + return this.get('transform'); + }; + }; + var SvgElemLink = function (obj, inherits) { + if (inherits && inherits.isText) { + SvgElemTspan.call(this, obj, inherits); + this.allowedChildren = ['textPath', 'tspan', '#text', '#cdata-section', 'a']; + } else { + SvgElemGroup.call(this, obj, inherits); + } + this.link = this.attr('href') || this.attr('xlink:href'); + this.addLink = function () { + if (this.link.match(/^(?:[a-z][a-z0-9+.-]*:|\/\/)?/i) && this.getChildren().length) { + let bbox = this.getBoundingShape().transform(getGlobalMatrix()).getBoundingBox(); + docInsertLink(bbox[0], bbox[1], bbox[2], bbox[3], this.link); + } + }; + }; + var SvgElemSvg = function (obj, inherits) { + SvgElemContainer.call(this, obj, inherits); + let width = this.getLength('width', this.getParentVWidth(), this.getParentVWidth()), + height = this.getLength('height', this.getParentVHeight(), this.getParentVHeight()), + x = this.getLength('x', this.getParentVWidth(), 0), + y = this.getLength('y', this.getParentVHeight(), 0); + if (inherits instanceof SvgElemUse) { + width = inherits.getLength('width', inherits.getParentVWidth(), width); + height = inherits.getLength('height', inherits.getParentVHeight(), height); + } + let aspectRatio = this.attr('preserveAspectRatio'), + viewBox = this.getViewbox('viewBox', [0, 0, width, height]); + if (this.isOuterElement && preserveAspectRatio) { + x = y = 0; + width = viewportWidth; + height = viewportHeight; + aspectRatio = preserveAspectRatio; + } + this.getVWidth = function () { + return viewBox[2]; + }; + this.getVHeight = function () { + return viewBox[3]; + }; + this.drawInDocument = function (isClip, isMask) { + doc.save(); + if (this.get('overflow') === 'hidden') { + new SvgShape().M(x, y).L(x + width, y).L(x + width, y + height).L(x, y + height).Z().transform(this.get('transform')).insertInDocument(); + doc.clip(); + } + this.drawContent(isClip, isMask); + doc.restore(); + }; + this.getTransformation = function () { + return multiplyMatrix(this.get('transform'), [1, 0, 0, 1, x, y], parseAspectRatio(aspectRatio, width, height, viewBox[2], viewBox[3]), [1, 0, 0, 1, -viewBox[0], -viewBox[1]]); + }; + }; + var SVGElemImage = function (obj, inherits) { + SvgElemStylable.call(this, obj, inherits); + let link = imageCallback(this.attr('href') || this.attr('xlink:href') || ''), + x = this.getLength('x', this.getVWidth(), 0), + y = this.getLength('y', this.getVHeight(), 0), + width = this.getLength('width', this.getVWidth(), 'auto'), + height = this.getLength('height', this.getVHeight(), 'auto'), + image; + try { + image = doc.openImage(link); + } catch (e) { + warningCallback('SVGElemImage: failed to open image "' + link + '" in PDFKit'); + } + if (image) { + if (width === 'auto' && height !== 'auto') { + width = height * image.width / image.height; + } else if (height === 'auto' && width !== 'auto') { + height = width * image.height / image.width; + } else if (width === 'auto' && height === 'auto') { + width = image.width; + height = image.height; + } + } + if (width === 'auto' || width < 0) { + width = 0; + } + if (height === 'auto' || height < 0) { + height = 0; + } + this.getTransformation = function () { + return this.get('transform'); + }; + this.getBoundingShape = function () { + return new SvgShape().M(x, y).L(x + width, y).M(x + width, y + height).L(x, y + height); + }; + this.drawInDocument = function (isClip, isMask) { + if (this.get('visibility') === 'hidden' || !image) { + return; + } + doc.save(); + this.transform(); + if (this.get('overflow') === 'hidden') { + doc.rect(x, y, width, height).clip(); + } + this.clip(); + this.mask(); + doc.translate(x, y); + doc.transform.apply(doc, parseAspectRatio(this.attr('preserveAspectRatio'), width, height, image ? image.width : width, image ? image.height : height)); + if (!isClip) { + doc.fillOpacity(this.get('opacity')); + doc.image(image, 0, 0); + } else { + doc.rect(0, 0, image.width, image.height); + docFillColor(DefaultColors.white).fill(); + } + doc.restore(); + }; + }; + var SvgElemPattern = function (obj, inherits, fallback) { + SvgElemHasChildren.call(this, obj, inherits); + this.ref = function () { + let ref = this.getUrl('href') || this.getUrl('xlink:href'); + if (ref && ref.nodeName === obj.nodeName) { + return new SvgElemPattern(ref, inherits, fallback); + } + }.call(this); + let _attr = this.attr; + this.attr = function (key) { + let attr = _attr.call(this, key); + if (attr != null || key === 'href' || key === 'xlink:href') { + return attr; + } + return this.ref ? this.ref.attr(key) : null; + }; + let _getChildren = this.getChildren; + this.getChildren = function () { + let children = _getChildren.call(this); + if (children.length > 0) { + return children; + } + return this.ref ? this.ref.getChildren() : []; + }; + this.getPaint = function (bBox, gOpacity, isClip, isMask) { + let bBoxUnitsPattern = this.attr('patternUnits') !== 'userSpaceOnUse', + bBoxUnitsContent = this.attr('patternContentUnits') === 'objectBoundingBox', + x = this.getLength('x', bBoxUnitsPattern ? 1 : this.getParentVWidth(), 0), + y = this.getLength('y', bBoxUnitsPattern ? 1 : this.getParentVHeight(), 0), + width = this.getLength('width', bBoxUnitsPattern ? 1 : this.getParentVWidth(), 0), + height = this.getLength('height', bBoxUnitsPattern ? 1 : this.getParentVHeight(), 0); + if (bBoxUnitsContent && !bBoxUnitsPattern) { + // Use the same units for pattern & pattern content + x = (x - bBox[0]) / (bBox[2] - bBox[0]) || 0; + y = (y - bBox[1]) / (bBox[3] - bBox[1]) || 0; + width = width / (bBox[2] - bBox[0]) || 0; + height = height / (bBox[3] - bBox[1]) || 0; + } else if (!bBoxUnitsContent && bBoxUnitsPattern) { + x = bBox[0] + x * (bBox[2] - bBox[0]); + y = bBox[1] + y * (bBox[3] - bBox[1]); + width = width * (bBox[2] - bBox[0]); + height = height * (bBox[3] - bBox[1]); + } + let viewBox = this.getViewbox('viewBox', [0, 0, width, height]), + aspectRatio = (this.attr('preserveAspectRatio') || '').trim(), + aspectRatioMatrix = multiplyMatrix(parseAspectRatio(aspectRatio, width, height, viewBox[2], viewBox[3], 0), [1, 0, 0, 1, -viewBox[0], -viewBox[1]]), + matrix = parseTranform(this.attr('patternTransform')); + if (bBoxUnitsContent) { + matrix = multiplyMatrix([bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]], matrix); + } + matrix = multiplyMatrix(matrix, [1, 0, 0, 1, x, y]); + if ((matrix = validateMatrix(matrix)) && (aspectRatioMatrix = validateMatrix(aspectRatioMatrix)) && (width = validateNumber(width)) && (height = validateNumber(height))) { + let group = docBeginGroup([0, 0, width, height]); + doc.transform.apply(doc, aspectRatioMatrix); + this.drawChildren(isClip, isMask); + docEndGroup(group); + return [docCreatePattern(group, width, height, matrix), gOpacity]; + } else { + return fallback ? [fallback[0], fallback[1] * gOpacity] : undefined; + } + }; + this.getVWidth = function () { + let bBoxUnitsPattern = this.attr('patternUnits') !== 'userSpaceOnUse', + width = this.getLength('width', bBoxUnitsPattern ? 1 : this.getParentVWidth(), 0); + return this.getViewbox('viewBox', [0, 0, width, 0])[2]; + }; + this.getVHeight = function () { + let bBoxUnitsPattern = this.attr('patternUnits') !== 'userSpaceOnUse', + height = this.getLength('height', bBoxUnitsPattern ? 1 : this.getParentVHeight(), 0); + return this.getViewbox('viewBox', [0, 0, 0, height])[3]; + }; + }; + var SvgElemGradient = function (obj, inherits, fallback) { + SvgElem.call(this, obj, inherits); + this.allowedChildren = ['stop']; + this.ref = function () { + let ref = this.getUrl('href') || this.getUrl('xlink:href'); + if (ref && ref.nodeName === obj.nodeName) { + return new SvgElemGradient(ref, inherits, fallback); + } + }.call(this); + let _attr = this.attr; + this.attr = function (key) { + let attr = _attr.call(this, key); + if (attr != null || key === 'href' || key === 'xlink:href') { + return attr; + } + return this.ref ? this.ref.attr(key) : null; + }; + let _getChildren = this.getChildren; + this.getChildren = function () { + let children = _getChildren.call(this); + if (children.length > 0) { + return children; + } + return this.ref ? this.ref.getChildren() : []; + }; + this.getPaint = function (bBox, gOpacity, isClip, isMask) { + let children = this.getChildren(); + if (children.length === 0) { + return; + } + if (children.length === 1) { + let child = children[0], + stopColor = child.get('stop-color'); + if (stopColor === 'none') { + return; + } + return opacityToColor(stopColor, child.get('stop-opacity') * gOpacity, isMask); + } + let bBoxUnits = this.attr('gradientUnits') !== 'userSpaceOnUse', + matrix = parseTranform(this.attr('gradientTransform')), + spread = this.attr('spreadMethod'), + grad, + x1, + x2, + y1, + y2, + r2, + nAfter = 0, + nBefore = 0, + nTotal = 1; + if (bBoxUnits) { + matrix = multiplyMatrix([bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]], matrix); + } + if (matrix = validateMatrix(matrix)) { + if (this.name === 'linearGradient') { + x1 = this.getLength('x1', bBoxUnits ? 1 : this.getVWidth(), 0); + x2 = this.getLength('x2', bBoxUnits ? 1 : this.getVWidth(), bBoxUnits ? 1 : this.getVWidth()); + y1 = this.getLength('y1', bBoxUnits ? 1 : this.getVHeight(), 0); + y2 = this.getLength('y2', bBoxUnits ? 1 : this.getVHeight(), 0); + } else { + x2 = this.getLength('cx', bBoxUnits ? 1 : this.getVWidth(), bBoxUnits ? 0.5 : 0.5 * this.getVWidth()); + y2 = this.getLength('cy', bBoxUnits ? 1 : this.getVHeight(), bBoxUnits ? 0.5 : 0.5 * this.getVHeight()); + r2 = this.getLength('r', bBoxUnits ? 1 : this.getViewport(), bBoxUnits ? 0.5 : 0.5 * this.getViewport()); + x1 = this.getLength('fx', bBoxUnits ? 1 : this.getVWidth(), x2); + y1 = this.getLength('fy', bBoxUnits ? 1 : this.getVHeight(), y2); + if (r2 < 0) { + warningCallback('SvgElemGradient: negative r value'); + } + let d = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2)), + multiplier = 1; + if (d > r2) { + // according to specification + multiplier = r2 / d; + x1 = x2 + (x1 - x2) * multiplier; + y1 = y2 + (y1 - y2) * multiplier; + } + r2 = Math.max(r2, d * multiplier * (1 + 1e-6)); // fix for edge-case gradients see issue #84 + } + if (spread === 'reflect' || spread === 'repeat') { + let inv = inverseMatrix(matrix), + corner1 = transformPoint([bBox[0], bBox[1]], inv), + corner2 = transformPoint([bBox[2], bBox[1]], inv), + corner3 = transformPoint([bBox[2], bBox[3]], inv), + corner4 = transformPoint([bBox[0], bBox[3]], inv); + if (this.name === 'linearGradient') { + // See file 'gradient-repeat-maths.png' + nAfter = Math.max((corner1[0] - x2) * (x2 - x1) + (corner1[1] - y2) * (y2 - y1), (corner2[0] - x2) * (x2 - x1) + (corner2[1] - y2) * (y2 - y1), (corner3[0] - x2) * (x2 - x1) + (corner3[1] - y2) * (y2 - y1), (corner4[0] - x2) * (x2 - x1) + (corner4[1] - y2) * (y2 - y1)) / (Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2)); + nBefore = Math.max((corner1[0] - x1) * (x1 - x2) + (corner1[1] - y1) * (y1 - y2), (corner2[0] - x1) * (x1 - x2) + (corner2[1] - y1) * (y1 - y2), (corner3[0] - x1) * (x1 - x2) + (corner3[1] - y1) * (y1 - y2), (corner4[0] - x1) * (x1 - x2) + (corner4[1] - y1) * (y1 - y2)) / (Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2)); + } else { + nAfter = Math.sqrt(Math.max(Math.pow(corner1[0] - x2, 2) + Math.pow(corner1[1] - y2, 2), Math.pow(corner2[0] - x2, 2) + Math.pow(corner2[1] - y2, 2), Math.pow(corner3[0] - x2, 2) + Math.pow(corner3[1] - y2, 2), Math.pow(corner4[0] - x2, 2) + Math.pow(corner4[1] - y2, 2))) / r2 - 1; + } + nAfter = Math.ceil(nAfter + 0.5); // Add a little more because the stroke can extend outside of the bounding box + nBefore = Math.ceil(nBefore + 0.5); + nTotal = nBefore + 1 + nAfter; // How many times the gradient needs to be repeated to fill the object bounding box + } + if (this.name === 'linearGradient') { + grad = doc.linearGradient(x1 - nBefore * (x2 - x1), y1 - nBefore * (y2 - y1), x2 + nAfter * (x2 - x1), y2 + nAfter * (y2 - y1)); + } else { + grad = doc.radialGradient(x1, y1, 0, x2, y2, r2 + nAfter * r2); + } + for (let n = 0; n < nTotal; n++) { + let offset = 0, + inOrder = spread !== 'reflect' || (n - nBefore) % 2 === 0; + for (let i = 0; i < children.length; i++) { + let child = children[inOrder ? i : children.length - 1 - i], + stopColor = child.get('stop-color'); + if (stopColor === 'none') { + stopColor = DefaultColors.transparent; + } + stopColor = opacityToColor(stopColor, child.get('stop-opacity') * gOpacity, isMask); + offset = Math.max(offset, inOrder ? child.getPercent('offset', 0) : 1 - child.getPercent('offset', 0)); + if (i === 0 && stopColor[0].length === 4) { + grad._colorSpace = 'DeviceCMYK'; + } // Fix until PR #763 is merged into PDFKit + if (i === 0 && offset > 0) { + grad.stop((n + 0) / nTotal, stopColor[0], stopColor[1]); + } + grad.stop((n + offset) / (nAfter + nBefore + 1), stopColor[0], stopColor[1]); + if (i === children.length - 1 && offset < 1) { + grad.stop((n + 1) / nTotal, stopColor[0], stopColor[1]); + } + } + } + grad.setTransform.apply(grad, matrix); + return [grad, 1]; + } else { + return fallback ? [fallback[0], fallback[1] * gOpacity] : undefined; + } + }; + }; + var SvgElemBasicShape = function (obj, inherits) { + SvgElemStylable.call(this, obj, inherits); + this.dashScale = 1; + this.getBoundingShape = function () { + return this.shape; + }; + this.getTransformation = function () { + return this.get('transform'); + }; + this.drawInDocument = function (isClip, isMask) { + if (this.get('visibility') === 'hidden' || !this.shape) { + return; + } + doc.save(); + if (this.get('vector-effect') === 'non-scaling-stroke') { + this.shape.transform(this.getTransformation()); + } else { + this.transform(); + } + this.clip(); + if (!isClip) { + let masked = this.mask(), + group; + if (masked) { + group = docBeginGroup(getPageBBox()); + } + let subPaths = this.shape.getSubPaths(), + fill = this.getFill(isClip, isMask), + stroke = this.getStroke(isClip, isMask), + lineWidth = this.get('stroke-width'), + lineCap = this.get('stroke-linecap'); + if (this.get('vector-effect') === 'non-scaling-stroke') { + lineWidth = lineWidth / getPageScale(); + } + if (fill || stroke) { + if (fill) { + docFillColor(fill); + } + if (stroke) { + for (let j = 0; j < subPaths.length; j++) { + if (isEqual(subPaths[j].totalLength, 0)) { + if ((lineCap === 'square' || lineCap === 'round') && lineWidth > 0) { + if (subPaths[j].startPoint && subPaths[j].startPoint.length > 1) { + let x = subPaths[j].startPoint[0], + y = subPaths[j].startPoint[1]; + docFillColor(stroke); + if (lineCap === 'square') { + doc.rect(x - 0.5 * lineWidth, y - 0.5 * lineWidth, lineWidth, lineWidth); + } else if (lineCap === 'round') { + doc.circle(x, y, 0.5 * lineWidth); + } + doc.fill(); + } + } + } + } + let dashArray = this.get('stroke-dasharray'), + dashOffset = this.get('stroke-dashoffset'); + if (isNotEqual(this.dashScale, 1)) { + for (let j = 0; j < dashArray.length; j++) { + dashArray[j] *= this.dashScale; + } + dashOffset *= this.dashScale; + } + docStrokeColor(stroke); + doc.lineWidth(lineWidth).miterLimit(this.get('stroke-miterlimit')).lineJoin(this.get('stroke-linejoin')).lineCap(lineCap); + docApplyDash(dashArray, dashOffset); + } + for (let j = 0; j < subPaths.length; j++) { + if (subPaths[j].totalLength > 0) { + subPaths[j].insertInDocument(); + } + } + if (fill && stroke) { + doc.fillAndStroke(this.get('fill-rule')); + } else if (fill) { + doc.fill(this.get('fill-rule')); + } else if (stroke) { + doc.stroke(); + } + } + let markerStart = this.get('marker-start'), + markerMid = this.get('marker-mid'), + markerEnd = this.get('marker-end'); + if (markerStart !== 'none' || markerMid !== 'none' || markerEnd !== 'none') { + let markersPos = this.shape.getMarkers(); + if (markerStart !== 'none' && markersPos.length > 0) { + let marker = new SvgElemMarker(markerStart, null); + marker.drawMarker(false, isMask, markersPos[0], lineWidth); + } + if (markerMid !== 'none') { + for (let i = 1; i < markersPos.length - 1; i++) { + let marker = new SvgElemMarker(markerMid, null); + marker.drawMarker(false, isMask, markersPos[i], lineWidth); + } + } + if (markerEnd !== 'none' && markersPos.length > 0) { + let marker = new SvgElemMarker(markerEnd, null); + marker.drawMarker(false, isMask, markersPos[markersPos.length - 1], lineWidth); + } + } + if (group) { + docEndGroup(group); + docInsertGroup(group); + } + } else { + this.shape.insertInDocument(); + docFillColor(DefaultColors.white); + doc.fill(this.get('clip-rule')); + } + doc.restore(); + }; + }; + var SvgElemRect = function (obj, inherits) { + SvgElemBasicShape.call(this, obj, inherits); + let x = this.getLength('x', this.getVWidth(), 0), + y = this.getLength('y', this.getVHeight(), 0), + w = this.getLength('width', this.getVWidth(), 0), + h = this.getLength('height', this.getVHeight(), 0), + rx = this.getLength('rx', this.getVWidth()), + ry = this.getLength('ry', this.getVHeight()); + if (rx === undefined && ry === undefined) { + rx = ry = 0; + } else if (rx === undefined && ry !== undefined) { + rx = ry; + } else if (rx !== undefined && ry === undefined) { + ry = rx; + } + if (w > 0 && h > 0) { + if (rx && ry) { + rx = Math.min(rx, 0.5 * w); + ry = Math.min(ry, 0.5 * h); + this.shape = new SvgShape().M(x + rx, y).L(x + w - rx, y).A(rx, ry, 0, 0, 1, x + w, y + ry).L(x + w, y + h - ry).A(rx, ry, 0, 0, 1, x + w - rx, y + h).L(x + rx, y + h).A(rx, ry, 0, 0, 1, x, y + h - ry).L(x, y + ry).A(rx, ry, 0, 0, 1, x + rx, y).Z(); + } else { + this.shape = new SvgShape().M(x, y).L(x + w, y).L(x + w, y + h).L(x, y + h).Z(); + } + } else { + this.shape = new SvgShape(); + } + }; + var SvgElemCircle = function (obj, inherits) { + SvgElemBasicShape.call(this, obj, inherits); + let cx = this.getLength('cx', this.getVWidth(), 0), + cy = this.getLength('cy', this.getVHeight(), 0), + r = this.getLength('r', this.getViewport(), 0); + if (r > 0) { + this.shape = new SvgShape().M(cx + r, cy).A(r, r, 0, 0, 1, cx - r, cy).A(r, r, 0, 0, 1, cx + r, cy).Z(); + } else { + this.shape = new SvgShape(); + } + }; + var SvgElemEllipse = function (obj, inherits) { + SvgElemBasicShape.call(this, obj, inherits); + let cx = this.getLength('cx', this.getVWidth(), 0), + cy = this.getLength('cy', this.getVHeight(), 0), + rx = this.getLength('rx', this.getVWidth(), 0), + ry = this.getLength('ry', this.getVHeight(), 0); + if (rx > 0 && ry > 0) { + this.shape = new SvgShape().M(cx + rx, cy).A(rx, ry, 0, 0, 1, cx - rx, cy).A(rx, ry, 0, 0, 1, cx + rx, cy).Z(); + } else { + this.shape = new SvgShape(); + } + }; + var SvgElemLine = function (obj, inherits) { + SvgElemBasicShape.call(this, obj, inherits); + let x1 = this.getLength('x1', this.getVWidth(), 0), + y1 = this.getLength('y1', this.getVHeight(), 0), + x2 = this.getLength('x2', this.getVWidth(), 0), + y2 = this.getLength('y2', this.getVHeight(), 0); + this.shape = new SvgShape().M(x1, y1).L(x2, y2); + }; + var SvgElemPolyline = function (obj, inherits) { + SvgElemBasicShape.call(this, obj, inherits); + let points = this.getNumberList('points'); + this.shape = new SvgShape(); + for (let i = 0; i < points.length - 1; i += 2) { + if (i === 0) { + this.shape.M(points[i], points[i + 1]); + } else { + this.shape.L(points[i], points[i + 1]); + } + } + if (points.error) { + warningCallback('SvgElemPolygon: unexpected string ' + points.error); + } + if (points.length % 2 === 1) { + warningCallback('SvgElemPolyline: uneven number of coordinates'); + } + }; + var SvgElemPolygon = function (obj, inherits) { + SvgElemBasicShape.call(this, obj, inherits); + let points = this.getNumberList('points'); + this.shape = new SvgShape(); + for (let i = 0; i < points.length - 1; i += 2) { + if (i === 0) { + this.shape.M(points[i], points[i + 1]); + } else { + this.shape.L(points[i], points[i + 1]); + } + } + this.shape.Z(); + if (points.error) { + warningCallback('SvgElemPolygon: unexpected string ' + points.error); + } + if (points.length % 2 === 1) { + warningCallback('SvgElemPolygon: uneven number of coordinates'); + } + }; + var SvgElemPath = function (obj, inherits) { + SvgElemBasicShape.call(this, obj, inherits); + this.shape = new SvgShape().path(this.attr('d')); + let pathLength = this.getLength('pathLength', this.getViewport()); + this.pathLength = pathLength > 0 ? pathLength : undefined; + this.dashScale = this.pathLength !== undefined ? this.shape.totalLength / this.pathLength : 1; + }; + var SvgElemMarker = function (obj, inherits) { + SvgElemHasChildren.call(this, obj, inherits); + let width = this.getLength('markerWidth', this.getParentVWidth(), 3), + height = this.getLength('markerHeight', this.getParentVHeight(), 3), + viewBox = this.getViewbox('viewBox', [0, 0, width, height]); + this.getVWidth = function () { + return viewBox[2]; + }; + this.getVHeight = function () { + return viewBox[3]; + }; + this.drawMarker = function (isClip, isMask, posArray, strokeWidth) { + doc.save(); + let orient = this.attr('orient'), + units = this.attr('markerUnits'), + rotate = orient === 'auto' ? posArray[2] : (parseFloat(orient) || 0) * Math.PI / 180, + scale = units === 'userSpaceOnUse' ? 1 : strokeWidth; + doc.transform(Math.cos(rotate) * scale, Math.sin(rotate) * scale, -Math.sin(rotate) * scale, Math.cos(rotate) * scale, posArray[0], posArray[1]); + let refX = this.getLength('refX', this.getVWidth(), 0), + refY = this.getLength('refY', this.getVHeight(), 0), + aspectRatioMatrix = parseAspectRatio(this.attr('preserveAspectRatio'), width, height, viewBox[2], viewBox[3], 0.5); + if (this.get('overflow') === 'hidden') { + doc.rect(aspectRatioMatrix[0] * (viewBox[0] + viewBox[2] / 2 - refX) - width / 2, aspectRatioMatrix[3] * (viewBox[1] + viewBox[3] / 2 - refY) - height / 2, width, height).clip(); + } + doc.transform.apply(doc, aspectRatioMatrix); + doc.translate(-refX, -refY); + let group; + if (this.get('opacity') < 1 && !isClip) { + group = docBeginGroup(getPageBBox()); + } + this.drawChildren(isClip, isMask); + if (group) { + docEndGroup(group); + doc.fillOpacity(this.get('opacity')); + docInsertGroup(group); + } + doc.restore(); + }; + }; + var SvgElemClipPath = function (obj, inherits) { + SvgElemHasChildren.call(this, obj, inherits); + this.useMask = function (bBox) { + let group = docBeginGroup(getPageBBox()); + doc.save(); + doc.transform.apply(doc, this.get('transform')); + if (this.attr('clipPathUnits') === 'objectBoundingBox') { + doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]); + } + this.clip(); + this.drawChildren(true, false); + doc.restore(); + docEndGroup(group); + docApplyMask(group, true); + }; + }; + var SvgElemMask = function (obj, inherits) { + SvgElemHasChildren.call(this, obj, inherits); + this.useMask = function (bBox) { + let group = docBeginGroup(getPageBBox()); + doc.save(); + let x, y, w, h; + if (this.attr('maskUnits') === 'userSpaceOnUse') { + x = this.getLength('x', this.getVWidth(), -0.1 * (bBox[2] - bBox[0]) + bBox[0]); + y = this.getLength('y', this.getVHeight(), -0.1 * (bBox[3] - bBox[1]) + bBox[1]); + w = this.getLength('width', this.getVWidth(), 1.2 * (bBox[2] - bBox[0])); + h = this.getLength('height', this.getVHeight(), 1.2 * (bBox[3] - bBox[1])); + } else { + x = this.getLength('x', this.getVWidth(), -0.1) * (bBox[2] - bBox[0]) + bBox[0]; + y = this.getLength('y', this.getVHeight(), -0.1) * (bBox[3] - bBox[1]) + bBox[1]; + w = this.getLength('width', this.getVWidth(), 1.2) * (bBox[2] - bBox[0]); + h = this.getLength('height', this.getVHeight(), 1.2) * (bBox[3] - bBox[1]); + } + if (this.attr('maskContentUnits') === 'objectBoundingBox') { + doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]); + } + this.clip(); + this.drawChildren(false, true); + doc.restore(); + docEndGroup(group); + docApplyMask(group, true); + }; + }; + var SvgElemTextContainer = function (obj, inherits) { + SvgElemStylable.call(this, obj, inherits); + this.allowedChildren = ['tspan', '#text', '#cdata-section', 'a']; + this.isText = true; + this.getBoundingShape = function () { + let shape = new SvgShape(); + for (let i = 0; i < this._pos.length; i++) { + let pos = this._pos[i]; + if (!pos.hidden) { + let dx0 = pos.ascent * Math.sin(pos.rotate), + dy0 = -pos.ascent * Math.cos(pos.rotate), + dx1 = pos.descent * Math.sin(pos.rotate), + dy1 = -pos.descent * Math.cos(pos.rotate), + dx2 = pos.width * Math.cos(pos.rotate), + dy2 = pos.width * Math.sin(pos.rotate); + shape.M(pos.x + dx0, pos.y + dy0).L(pos.x + dx0 + dx2, pos.y + dy0 + dy2).M(pos.x + dx1 + dx2, pos.y + dy1 + dy2).L(pos.x + dx1, pos.y + dy1); + } + } + return shape; + }; + this.drawTextInDocument = function (isClip, isMask) { + if (this.link && !isClip && !isMask) { + this.addLink(); + } + if (this.get('text-decoration') === 'underline') { + this.decorate(0.05 * this._font.size, -0.075 * this._font.size, isClip, isMask); + } + if (this.get('text-decoration') === 'overline') { + this.decorate(0.05 * this._font.size, getAscent(this._font.font, this._font.size) + 0.075 * this._font.size, isClip, isMask); + } + let fill = this.getFill(isClip, isMask), + stroke = this.getStroke(isClip, isMask), + strokeWidth = this.get('stroke-width'); + if (this._font.fauxBold) { + if (!stroke) { + stroke = fill; + strokeWidth = this._font.size * 0.03; + } else { + strokeWidth += this._font.size * 0.03; + } + } + let children = this.getChildren(); + for (let i = 0; i < children.length; i++) { + let childElem = children[i]; + switch (childElem.name) { + case 'tspan': + case 'textPath': + case 'a': + if (childElem.get('display') !== 'none') { + childElem.drawTextInDocument(isClip, isMask); + } + break; + case '#text': + case '#cdata-section': + if (this.get('visibility') === 'hidden') { + continue; + } + if (fill || stroke || isClip) { + if (fill) { + docFillColor(fill); + } + if (stroke && strokeWidth) { + docStrokeColor(stroke); + doc.lineWidth(strokeWidth).miterLimit(this.get('stroke-miterlimit')).lineJoin(this.get('stroke-linejoin')).lineCap(this.get('stroke-linecap')); + docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset')); + } + docBeginText(this._font.font, this._font.size); + docSetTextMode(!!fill, !!stroke); + docWriteGlyphs(childElem._pos, this._font); + docEndText(); + } + break; + } + } + if (this.get('text-decoration') === 'line-through') { + this.decorate(0.05 * this._font.size, 0.5 * (getAscent(this._font.font, this._font.size) + getDescent(this._font.font, this._font.size)), isClip, isMask); + } + }; + this.decorate = function (lineWidth, linePosition, isClip, isMask) { + let fill = this.getFill(isClip, isMask), + stroke = this.getStroke(isClip, isMask); + if (fill) { + docFillColor(fill); + } + if (stroke) { + docStrokeColor(stroke); + doc.lineWidth(this.get('stroke-width')).miterLimit(this.get('stroke-miterlimit')).lineJoin(this.get('stroke-linejoin')).lineCap(this.get('stroke-linecap')); + docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset')); + } + for (let j = 0, pos = this._pos; j < pos.length; j++) { + if (!pos[j].hidden && isNotEqual(pos[j].width, 0)) { + let dx0 = (linePosition + lineWidth / 2) * Math.sin(pos[j].rotate), + dy0 = -(linePosition + lineWidth / 2) * Math.cos(pos[j].rotate), + dx1 = (linePosition - lineWidth / 2) * Math.sin(pos[j].rotate), + dy1 = -(linePosition - lineWidth / 2) * Math.cos(pos[j].rotate), + dx2 = pos[j].width * Math.cos(pos[j].rotate), + dy2 = pos[j].width * Math.sin(pos[j].rotate); + new SvgShape().M(pos[j].x + dx0, pos[j].y + dy0).L(pos[j].x + dx0 + dx2, pos[j].y + dy0 + dy2).L(pos[j].x + dx1 + dx2, pos[j].y + dy1 + dy2).L(pos[j].x + dx1, pos[j].y + dy1).Z().insertInDocument(); + if (fill && stroke) { + doc.fillAndStroke(); + } else if (fill) { + doc.fill(); + } else if (stroke) { + doc.stroke(); + } + } + } + }; + }; + var SvgElemTextNode = function (obj, inherits) { + this.name = obj.nodeName; + this.textContent = obj.nodeValue; + }; + var SvgElemTspan = function (obj, inherits) { + SvgElemTextContainer.call(this, obj, inherits); + }; + var SvgElemTextPath = function (obj, inherits) { + SvgElemTextContainer.call(this, obj, inherits); + let pathObject, pathLength, temp; + if ((temp = this.attr('path')) && temp.trim() !== '') { + let pathLength = this.getLength('pathLength', this.getViewport()); + this.pathObject = new SvgShape().path(temp); + this.pathLength = pathLength > 0 ? pathLength : this.pathObject.totalLength; + this.pathScale = this.pathObject.totalLength / this.pathLength; + } else if ((temp = this.getUrl('href') || this.getUrl('xlink:href')) && temp.nodeName === 'path') { + let pathElem = new SvgElemPath(temp, this); + this.pathObject = pathElem.shape.clone().transform(pathElem.get('transform')); + this.pathLength = this.chooseValue(pathElem.pathLength, this.pathObject.totalLength); + this.pathScale = this.pathObject.totalLength / this.pathLength; + } + }; + var SvgElemText = function (obj, inherits) { + SvgElemTextContainer.call(this, obj, inherits); + this.allowedChildren = ['textPath', 'tspan', '#text', '#cdata-section', 'a']; + (function (textParentElem) { + let processedText = '', + remainingText = obj.textContent, + textPaths = [], + currentChunk = [], + currentAnchor, + currentDirection, + currentX = 0, + currentY = 0; + function doAnchoring() { + if (currentChunk.length) { + let last = currentChunk[currentChunk.length - 1]; + let first = currentChunk[0]; + let width = last.x + last.width - first.x; + let anchordx = { + 'startltr': 0, + 'middleltr': 0.5, + 'endltr': 1, + 'startrtl': 1, + 'middlertl': 0.5, + 'endrtl': 0 + }[currentAnchor + currentDirection] * width || 0; + for (let i = 0; i < currentChunk.length; i++) { + currentChunk[i].x -= anchordx; + } + } + currentChunk = []; + } + function adjustLength(pos, length, spacingAndGlyphs) { + let firstChar = pos[0], + lastChar = pos[pos.length - 1], + startX = firstChar.x, + endX = lastChar.x + lastChar.width; + if (spacingAndGlyphs) { + let textScale = length / (endX - startX); + if (textScale > 0 && textScale < Infinity) { + for (let j = 0; j < pos.length; j++) { + pos[j].continuous = false; + pos[j].x = startX + textScale * (pos[j].x - startX); + pos[j].scale *= textScale; + pos[j].width *= textScale; + } + } + } else { + if (pos.length >= 2) { + let spaceDiff = (length - (endX - startX)) / (pos.length - 1); + for (let j = 0; j < pos.length; j++) { + pos[j].continuous = false; + pos[j].x += j * spaceDiff; + } + } + } + currentX += length - (endX - startX); + } + function recursive(currentElem, parentElem) { + currentElem._x = combineArrays(currentElem.getLengthList('x', currentElem.getVWidth()), parentElem ? parentElem._x.slice(parentElem._pos.length) : []); + currentElem._y = combineArrays(currentElem.getLengthList('y', currentElem.getVHeight()), parentElem ? parentElem._y.slice(parentElem._pos.length) : []); + currentElem._dx = combineArrays(currentElem.getLengthList('dx', currentElem.getVWidth()), parentElem ? parentElem._dx.slice(parentElem._pos.length) : []); + currentElem._dy = combineArrays(currentElem.getLengthList('dy', currentElem.getVHeight()), parentElem ? parentElem._dy.slice(parentElem._pos.length) : []); + currentElem._rot = combineArrays(currentElem.getNumberList('rotate'), parentElem ? parentElem._rot.slice(parentElem._pos.length) : []); + currentElem._defRot = currentElem.chooseValue(currentElem._rot[currentElem._rot.length - 1], parentElem && parentElem._defRot, 0); + if (currentElem.name === 'textPath') { + currentElem._y = []; + } + let fontOptions = { + fauxItalic: false, + fauxBold: false + }, + fontNameorLink = fontCallback(currentElem.get('font-family'), currentElem.get('font-weight') === 'bold', currentElem.get('font-style') === 'italic', fontOptions); + try { + doc.font(fontNameorLink); + } catch (e) { + warningCallback('SVGElemText: failed to open font "' + fontNameorLink + '" in PDFKit: ' + e.message); + } + currentElem._pos = []; + currentElem._index = 0; + currentElem._font = { + font: doc._font, + size: currentElem.get('font-size'), + fauxItalic: fontOptions.fauxItalic, + fauxBold: fontOptions.fauxBold + }; + let textLength = currentElem.getLength('textLength', currentElem.getVWidth(), undefined), + spacingAndGlyphs = currentElem.attr('lengthAdjust') === 'spacingAndGlyphs', + wordSpacing = currentElem.get('word-spacing'), + letterSpacing = currentElem.get('letter-spacing'), + textAnchor = currentElem.get('text-anchor'), + textDirection = currentElem.get('direction'), + // `alignment-baseline` and `baseline-shift` have no effect on + // `` elements according to the SVG spec. So, detect when + // we're styling a `` element and ignore + // `alignment-baseline` (only factoring in `dominant-baseline`) + // and `baseline-shift` (which can only have the default value of + // `baseline`). + // + // Note that Chrome (as of v99) incorrectly factors in + // `alignment-baseline` on `` elements, while Firefox + // correctly follows the spec and ignores it. This means that our + // output will differ from Chrome's in these cases, but conform to + // SVG specification. + isTextElem = currentElem.name === 'text', + baselineAttr = isTextElem ? currentElem.get('dominant-baseline') : currentElem.get('alignment-baseline') || currentElem.get('dominant-baseline'), + baselineShiftAttr = isTextElem ? 'baseline' : currentElem.get('baseline-shift'), + baseline = getBaseline(currentElem._font.font, currentElem._font.size, baselineAttr, baselineShiftAttr); + if (currentElem.name === 'textPath') { + doAnchoring(); + currentX = currentY = 0; + } + let children = currentElem.getChildren(); + for (let i = 0; i < children.length; i++) { + let childElem = children[i]; + switch (childElem.name) { + case 'tspan': + case 'textPath': + case 'a': + recursive(childElem, currentElem); + break; + case '#text': + case '#cdata-section': + let rawText = childElem.textContent, + renderedText = rawText, + words; + childElem._font = currentElem._font; + childElem._pos = []; + remainingText = remainingText.substring(rawText.length); + if (currentElem.get('xml:space') === 'preserve') { + renderedText = renderedText.replace(/[\s]/g, ' '); + } else { + renderedText = renderedText.replace(/[\s]+/g, ' '); + if (processedText.match(/[\s]$|^$/)) { + renderedText = renderedText.replace(/^[\s]/, ''); + } + if (remainingText.match(/^[\s]*$/)) { + renderedText = renderedText.replace(/[\s]$/, ''); + } + } + processedText += rawText; + if (wordSpacing === 0) { + words = [renderedText]; + } else { + words = renderedText.split(/(\s)/); + } + for (let w = 0; w < words.length; w++) { + let pos = getTextPos(currentElem._font.font, currentElem._font.size, words[w]); + for (let j = 0; j < pos.length; j++) { + let index = currentElem._index, + xAttr = currentElem._x[index], + yAttr = currentElem._y[index], + dxAttr = currentElem._dx[index], + dyAttr = currentElem._dy[index], + rotAttr = currentElem._rot[index], + continuous = !(w === 0 && j === 0); + if (letterSpacing !== 0) { + continuous = false; + } + if (wordSpacing !== 0) { + continuous = false; + } + if (xAttr !== undefined) { + continuous = false; + doAnchoring(); + currentX = xAttr; + } + if (yAttr !== undefined) { + continuous = false; + doAnchoring(); + currentY = yAttr; + } + if (dxAttr !== undefined) { + continuous = false; + currentX += dxAttr; + } + if (dyAttr !== undefined) { + continuous = false; + currentY += dyAttr; + } + if (rotAttr !== undefined || currentElem._defRot !== 0) { + continuous = false; + } + let position = { + glyph: pos[j].glyph, + rotate: Math.PI / 180 * currentElem.chooseValue(rotAttr, currentElem._defRot), + x: currentX + pos[j].xOffset, + kern: pos[j].kern, + y: currentY + baseline + pos[j].yOffset, + width: pos[j].width, + ascent: getAscent(currentElem._font.font, currentElem._font.size), + descent: getDescent(currentElem._font.font, currentElem._font.size), + scale: 1, + hidden: false, + continuous: continuous + }; + currentChunk.push(position); + childElem._pos.push(position); + currentElem._pos.push(position); + currentElem._index += pos[j].unicode.length; + if (currentChunk.length === 1) { + currentAnchor = textAnchor; + currentDirection = textDirection; + } + currentX += pos[j].xAdvance + letterSpacing; + currentY += pos[j].yAdvance; + } + if (words[w] === ' ') { + currentX += wordSpacing; + } + } + break; + default: + remainingText = remainingText.substring(childElem.textContent.length); + } + } + if (textLength && currentElem._pos.length) { + adjustLength(currentElem._pos, textLength, spacingAndGlyphs); + } + if (currentElem.name === 'textPath' || currentElem.name === 'text') { + doAnchoring(); + } + if (currentElem.name === 'textPath') { + textPaths.push(currentElem); + let pathObject = currentElem.pathObject; + if (pathObject) { + currentX = pathObject.endPoint[0]; + currentY = pathObject.endPoint[1]; + } + } + if (parentElem) { + parentElem._pos = parentElem._pos.concat(currentElem._pos); + parentElem._index += currentElem._index; + } + } + function textOnPath(currentElem) { + let pathObject = currentElem.pathObject, + pathLength = currentElem.pathLength, + pathScale = currentElem.pathScale; + if (pathObject) { + let textOffset = currentElem.getLength('startOffset', pathLength, 0); + for (let j = 0; j < currentElem._pos.length; j++) { + let charMidX = textOffset + currentElem._pos[j].x + 0.5 * currentElem._pos[j].width; + if (charMidX > pathLength || charMidX < 0) { + currentElem._pos[j].hidden = true; + } else { + let pointOnPath = pathObject.getPointAtLength(charMidX * pathScale); + if (isNotEqual(pathScale, 1)) { + currentElem._pos[j].scale *= pathScale; + currentElem._pos[j].width *= pathScale; + } + currentElem._pos[j].x = pointOnPath[0] - 0.5 * currentElem._pos[j].width * Math.cos(pointOnPath[2]) - currentElem._pos[j].y * Math.sin(pointOnPath[2]); + currentElem._pos[j].y = pointOnPath[1] - 0.5 * currentElem._pos[j].width * Math.sin(pointOnPath[2]) + currentElem._pos[j].y * Math.cos(pointOnPath[2]); + currentElem._pos[j].rotate = pointOnPath[2] + currentElem._pos[j].rotate; + currentElem._pos[j].continuous = false; + } + } + } else { + for (let j = 0; j < currentElem._pos.length; j++) { + currentElem._pos[j].hidden = true; + } + } + } + recursive(textParentElem, null); + for (let i = 0; i < textPaths.length; i++) { + textOnPath(textPaths[i]); + } + })(this); + this.getTransformation = function () { + return this.get('transform'); + }; + this.drawInDocument = function (isClip, isMask) { + doc.save(); + this.transform(); + this.clip(); + let masked = this.mask(), + group; + if (masked) { + group = docBeginGroup(getPageBBox()); + } + this.drawTextInDocument(isClip, isMask); + if (group) { + docEndGroup(group); + docInsertGroup(group); + } + doc.restore(); + }; + }; + options = options || {}; + var pxToPt = options.assumePt ? 1 : 72 / 96, + // 1px = 72/96pt, but only if assumePt is false + viewportWidth = (options.width || doc.page.width) / pxToPt, + viewportHeight = (options.height || doc.page.height) / pxToPt, + preserveAspectRatio = options.preserveAspectRatio || null, + // default to null so that the attr can override if not passed + useCSS = options.useCSS && typeof SVGElement !== 'undefined' && svg instanceof SVGElement && typeof getComputedStyle === 'function', + warningCallback = options.warningCallback, + fontCallback = options.fontCallback, + imageCallback = options.imageCallback, + colorCallback = options.colorCallback, + documentCallback = options.documentCallback, + precision = Math.ceil(Math.max(1, options.precision)) || 3, + groupStack = [], + documentCache = {}, + links = [], + styleRules = []; + if (typeof warningCallback !== 'function') { + warningCallback = function (str) { + if (typeof console !== undefined && typeof console.warn === 'function') { + console.warn(str); + } + }; + } + if (typeof fontCallback !== 'function') { + fontCallback = function (family, bold, italic, fontOptions) { + // Check if the font is already registered in the document + if (bold && italic) { + if (doc._registeredFonts.hasOwnProperty(family + '-BoldItalic')) { + return family + '-BoldItalic'; + } else if (doc._registeredFonts.hasOwnProperty(family + '-Italic')) { + fontOptions.fauxBold = true; + return family + '-Italic'; + } else if (doc._registeredFonts.hasOwnProperty(family + '-Bold')) { + fontOptions.fauxItalic = true; + return family + '-Bold'; + } else if (doc._registeredFonts.hasOwnProperty(family)) { + fontOptions.fauxBold = true; + fontOptions.fauxItalic = true; + return family; + } + } + if (bold && !italic) { + if (doc._registeredFonts.hasOwnProperty(family + '-Bold')) { + return family + '-Bold'; + } else if (doc._registeredFonts.hasOwnProperty(family)) { + fontOptions.fauxBold = true; + return family; + } + } + if (!bold && italic) { + if (doc._registeredFonts.hasOwnProperty(family + '-Italic')) { + return family + '-Italic'; + } else if (doc._registeredFonts.hasOwnProperty(family)) { + fontOptions.fauxItalic = true; + return family; + } + } + if (!bold && !italic) { + if (doc._registeredFonts.hasOwnProperty(family)) { + return family; + } + } + // Use standard fonts as fallback + if (family.match(/(?:^|,)\s*serif\s*$/)) { + if (bold && italic) { + return 'Times-BoldItalic'; + } + if (bold && !italic) { + return 'Times-Bold'; + } + if (!bold && italic) { + return 'Times-Italic'; + } + if (!bold && !italic) { + return 'Times-Roman'; + } + } else if (family.match(/(?:^|,)\s*monospace\s*$/)) { + if (bold && italic) { + return 'Courier-BoldOblique'; + } + if (bold && !italic) { + return 'Courier-Bold'; + } + if (!bold && italic) { + return 'Courier-Oblique'; + } + if (!bold && !italic) { + return 'Courier'; + } + } else if (family.match(/(?:^|,)\s*sans-serif\s*$/) || true) { + if (bold && italic) { + return 'Helvetica-BoldOblique'; + } + if (bold && !italic) { + return 'Helvetica-Bold'; + } + if (!bold && italic) { + return 'Helvetica-Oblique'; + } + if (!bold && !italic) { + return 'Helvetica'; + } + } + }; + } + if (typeof imageCallback !== 'function') { + imageCallback = function (link) { + return link.replace(/\s+/g, ''); + }; + } + if (typeof colorCallback !== 'function') { + colorCallback = null; + } else { + for (let color in DefaultColors) { + let newColor = colorCallback(DefaultColors[color]); + DefaultColors[color][0] = newColor[0]; + DefaultColors[color][1] = newColor[1]; + } + } + if (typeof documentCallback !== 'function') { + documentCallback = null; + } + if (typeof svg === 'string') { + svg = parseXml(svg); + } + if (svg) { + let styles = svg.getElementsByTagName('style'); + for (let i = 0; i < styles.length; i++) { + styleRules = styleRules.concat(parseStyleSheet(styles[i].textContent)); + } + let elem = createSVGElement(svg, null); + if (typeof elem.drawInDocument === 'function') { + if (options.useCSS && !useCSS) { + warningCallback('SVGtoPDF: useCSS option can only be used for SVG *elements* in compatible browsers'); + } + let savedFillColor = doc._fillColor; + doc.save().translate(x || 0, y || 0).scale(pxToPt); + elem.drawInDocument(); + for (let i = 0; i < links.length; i++) { + doc.page.annotations.push(links[i]); + } + doc.restore(); + doc._fillColor = savedFillColor; + } else { + warningCallback('SVGtoPDF: this element can\'t be rendered directly: ' + svg.nodeName); + } + } else { + warningCallback('SVGtoPDF: the input does not look like a valid SVG'); + } +}; +if ( true && module && typeof module.exports !== 'undefined') { + module.exports = SVGtoPDF; +} + +/***/ }, + +/***/ 783 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +/* eslint-disable no-proto */ + + + +__webpack_require__(187); +__webpack_require__(8376); +__webpack_require__(6401); +__webpack_require__(2017); +const base64 = __webpack_require__(2504); +const ieee754 = __webpack_require__(9029); +const customInspectSymbol = typeof Symbol === 'function' && typeof Symbol['for'] === 'function' // eslint-disable-line dot-notation +? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation +: null; +exports.Buffer = Buffer; +exports.SlowBuffer = SlowBuffer; +exports.INSPECT_MAX_BYTES = 50; +const 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 { + const arr = new Uint8Array(1); + const proto = { + foo: function () { + return 42; + } + }; + Object.setPrototypeOf(proto, Uint8Array.prototype); + Object.setPrototypeOf(arr, proto); + 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 + const buf = new Uint8Array(length); + Object.setPrototypeOf(buf, 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); +} +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 fromArrayView(value); + } + if (value == null) { + throw new 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 SharedArrayBuffer !== 'undefined' && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) { + return fromArrayBuffer(value, encodingOrOffset, length); + } + if (typeof value === 'number') { + throw new TypeError('The "value" argument must not be of type number. Received type number'); + } + const valueOf = value.valueOf && value.valueOf(); + if (valueOf != null && valueOf !== value) { + return Buffer.from(valueOf, encodingOrOffset, length); + } + const 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 +Object.setPrototypeOf(Buffer.prototype, Uint8Array.prototype); +Object.setPrototypeOf(Buffer, 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 interpreted 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); + } + const length = byteLength(string, encoding) | 0; + let buf = createBuffer(length); + const 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) { + const length = array.length < 0 ? 0 : checked(array.length) | 0; + const buf = createBuffer(length); + for (let i = 0; i < length; i += 1) { + buf[i] = array[i] & 255; + } + return buf; +} +function fromArrayView(arrayView) { + if (isInstance(arrayView, Uint8Array)) { + const copy = new Uint8Array(arrayView); + return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength); + } + return fromArrayLike(arrayView); +} +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'); + } + let 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 + Object.setPrototypeOf(buf, Buffer.prototype); + return buf; +} +function fromObject(obj) { + if (Buffer.isBuffer(obj)) { + const len = checked(obj.length) | 0; + const 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; + let x = a.length; + let y = b.length; + for (let 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); + } + let i; + if (length === undefined) { + length = 0; + for (i = 0; i < list.length; ++i) { + length += list[i].length; + } + } + const buffer = Buffer.allocUnsafe(length); + let pos = 0; + for (i = 0; i < list.length; ++i) { + let buf = list[i]; + if (isInstance(buf, Uint8Array)) { + if (pos + buf.length > buffer.length) { + if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf); + buf.copy(buffer, pos); + } else { + Uint8Array.prototype.set.call(buffer, buf, pos); + } + } else if (!Buffer.isBuffer(buf)) { + throw new TypeError('"list" argument must be an Array of Buffers'); + } else { + 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); + } + const len = string.length; + const mustMatch = arguments.length > 2 && arguments[2] === true; + if (!mustMatch && len === 0) return 0; + + // Use a for loop to avoid recursion + let 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) { + let 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 coercion 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) { + const i = b[n]; + b[n] = b[m]; + b[m] = i; +} +Buffer.prototype.swap16 = function swap16() { + const len = this.length; + if (len % 2 !== 0) { + throw new RangeError('Buffer size must be a multiple of 16-bits'); + } + for (let i = 0; i < len; i += 2) { + swap(this, i, i + 1); + } + return this; +}; +Buffer.prototype.swap32 = function swap32() { + const len = this.length; + if (len % 4 !== 0) { + throw new RangeError('Buffer size must be a multiple of 32-bits'); + } + for (let i = 0; i < len; i += 4) { + swap(this, i, i + 3); + swap(this, i + 1, i + 2); + } + return this; +}; +Buffer.prototype.swap64 = function swap64() { + const len = this.length; + if (len % 8 !== 0) { + throw new RangeError('Buffer size must be a multiple of 64-bits'); + } + for (let 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() { + const 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() { + let str = ''; + const max = exports.INSPECT_MAX_BYTES; + str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim(); + if (this.length > max) str += ' ... '; + return ''; +}; +if (customInspectSymbol) { + Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect; +} +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; + let x = thisEnd - thisStart; + let y = end - start; + const len = Math.min(x, y); + const thisCopy = this.slice(thisStart, thisEnd); + const targetCopy = target.slice(start, end); + for (let 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) { + let indexSize = 1; + let arrLength = arr.length; + let 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); + } + } + let i; + if (dir) { + let 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--) { + let found = true; + for (let 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; + const remaining = buf.length - offset; + if (!length) { + length = remaining; + } else { + length = Number(length); + if (length > remaining) { + length = remaining; + } + } + const strLen = string.length; + if (length > strLen / 2) { + length = strLen / 2; + } + let i; + for (i = 0; i < length; ++i) { + const 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 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'); + } + const 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'; + let 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': + case 'latin1': + case 'binary': + return asciiWrite(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); + const res = []; + let i = start; + while (i < end) { + const firstByte = buf[i]; + let codePoint = null; + let bytesPerSequence = firstByte > 0xEF ? 4 : firstByte > 0xDF ? 3 : firstByte > 0xBF ? 2 : 1; + if (i + bytesPerSequence <= end) { + let 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 +const MAX_ARGUMENTS_LENGTH = 0x1000; +function decodeCodePointsArray(codePoints) { + const 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". + let res = ''; + let i = 0; + while (i < len) { + res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)); + } + return res; +} +function asciiSlice(buf, start, end) { + let ret = ''; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i] & 0x7F); + } + return ret; +} +function latin1Slice(buf, start, end) { + let ret = ''; + end = Math.min(buf.length, end); + for (let i = start; i < end; ++i) { + ret += String.fromCharCode(buf[i]); + } + return ret; +} +function hexSlice(buf, start, end) { + const len = buf.length; + if (!start || start < 0) start = 0; + if (!end || end < 0 || end > len) end = len; + let out = ''; + for (let i = start; i < end; ++i) { + out += hexSliceLookupTable[buf[i]]; + } + return out; +} +function utf16leSlice(buf, start, end) { + const bytes = buf.slice(start, end); + let res = ''; + // If bytes.length is odd, the last 8 bits must be ignored (same as node.js) + for (let i = 0; i < bytes.length - 1; i += 2) { + res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256); + } + return res; +} +Buffer.prototype.slice = function slice(start, end) { + const 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; + const newBuf = this.subarray(start, end); + // Return an augmented `Uint8Array` instance + Object.setPrototypeOf(newBuf, 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 = Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) { + offset = offset >>> 0; + byteLength = byteLength >>> 0; + if (!noAssert) checkOffset(offset, byteLength, this.length); + let val = this[offset]; + let mul = 1; + let i = 0; + while (++i < byteLength && (mul *= 0x100)) { + val += this[offset + i] * mul; + } + return val; +}; +Buffer.prototype.readUintBE = Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) { + offset = offset >>> 0; + byteLength = byteLength >>> 0; + if (!noAssert) { + checkOffset(offset, byteLength, this.length); + } + let val = this[offset + --byteLength]; + let mul = 1; + while (byteLength > 0 && (mul *= 0x100)) { + val += this[offset + --byteLength] * mul; + } + return val; +}; +Buffer.prototype.readUint8 = Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) { + offset = offset >>> 0; + if (!noAssert) checkOffset(offset, 1, this.length); + return this[offset]; +}; +Buffer.prototype.readUint16LE = 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 = 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 = 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 = 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.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, 'offset'); + const first = this[offset]; + const last = this[offset + 7]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8); + } + const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24; + const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24; + return BigInt(lo) + (BigInt(hi) << BigInt(32)); +}); +Buffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, 'offset'); + const first = this[offset]; + const last = this[offset + 7]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8); + } + const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last; + return (BigInt(hi) << BigInt(32)) + BigInt(lo); +}); +Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) { + offset = offset >>> 0; + byteLength = byteLength >>> 0; + if (!noAssert) checkOffset(offset, byteLength, this.length); + let val = this[offset]; + let mul = 1; + let 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); + let i = byteLength; + let mul = 1; + let 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); + const 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); + const 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.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) { + offset = offset >>> 0; + validateNumber(offset, 'offset'); + const first = this[offset]; + const last = this[offset + 7]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8); + } + const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24); // Overflow + + return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24); +}); +Buffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) { + offset = offset >>> 0; + validateNumber(offset, 'offset'); + const first = this[offset]; + const last = this[offset + 7]; + if (first === undefined || last === undefined) { + boundsError(offset, this.length - 8); + } + const val = (first << 24) + + // Overflow + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset]; + return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last); +}); +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 = Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength = byteLength >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength) - 1; + checkInt(this, value, offset, byteLength, maxBytes, 0); + } + let mul = 1; + let i = 0; + this[offset] = value & 0xFF; + while (++i < byteLength && (mul *= 0x100)) { + this[offset + i] = value / mul & 0xFF; + } + return offset + byteLength; +}; +Buffer.prototype.writeUintBE = Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) { + value = +value; + offset = offset >>> 0; + byteLength = byteLength >>> 0; + if (!noAssert) { + const maxBytes = Math.pow(2, 8 * byteLength) - 1; + checkInt(this, value, offset, byteLength, maxBytes, 0); + } + let i = byteLength - 1; + let mul = 1; + this[offset + i] = value & 0xFF; + while (--i >= 0 && (mul *= 0x100)) { + this[offset + i] = value / mul & 0xFF; + } + return offset + byteLength; +}; +Buffer.prototype.writeUint8 = 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 = 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 = 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 = 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 = 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; +}; +function wrtBigUInt64LE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(0xffffffff)); + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + lo = lo >> 8; + buf[offset++] = lo; + let hi = Number(value >> BigInt(32) & BigInt(0xffffffff)); + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + hi = hi >> 8; + buf[offset++] = hi; + return offset; +} +function wrtBigUInt64BE(buf, value, offset, min, max) { + checkIntBI(value, min, max, buf, offset, 7); + let lo = Number(value & BigInt(0xffffffff)); + buf[offset + 7] = lo; + lo = lo >> 8; + buf[offset + 6] = lo; + lo = lo >> 8; + buf[offset + 5] = lo; + lo = lo >> 8; + buf[offset + 4] = lo; + let hi = Number(value >> BigInt(32) & BigInt(0xffffffff)); + buf[offset + 3] = hi; + hi = hi >> 8; + buf[offset + 2] = hi; + hi = hi >> 8; + buf[offset + 1] = hi; + hi = hi >> 8; + buf[offset] = hi; + return offset + 8; +} +Buffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset) { + if (offset === void 0) { + offset = 0; + } + return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff')); +}); +Buffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset) { + if (offset === void 0) { + offset = 0; + } + return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff')); +}); +Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) { + value = +value; + offset = offset >>> 0; + if (!noAssert) { + const limit = Math.pow(2, 8 * byteLength - 1); + checkInt(this, value, offset, byteLength, limit - 1, -limit); + } + let i = 0; + let mul = 1; + let 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) { + const limit = Math.pow(2, 8 * byteLength - 1); + checkInt(this, value, offset, byteLength, limit - 1, -limit); + } + let i = byteLength - 1; + let mul = 1; + let 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; +}; +Buffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset) { + if (offset === void 0) { + offset = 0; + } + return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff')); +}); +Buffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset) { + if (offset === void 0) { + offset = 0; + } + return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff')); +}); +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; + } + const 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 { + 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) { + const 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; + } else if (typeof val === 'boolean') { + val = Number(val); + } + + // 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; + let i; + if (typeof val === 'number') { + for (i = start; i < end; ++i) { + this[i] = val; + } + } else { + const bytes = Buffer.isBuffer(val) ? val : Buffer.from(val, encoding); + const 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; +}; + +// CUSTOM ERRORS +// ============= + +// Simplified versions from Node, changed for Buffer-only usage +const errors = {}; +function E(sym, getMessage, Base) { + errors[sym] = class NodeError extends Base { + constructor() { + super(); + Object.defineProperty(this, 'message', { + value: getMessage.apply(this, arguments), + writable: true, + configurable: true + }); + + // Add the error code to the name to include it in the stack trace. + this.name = `${this.name} [${sym}]`; + // Access the stack to generate the error message including the error code + // from the name. + this.stack; // eslint-disable-line no-unused-expressions + // Reset the name to the actual name. + delete this.name; + } + get code() { + return sym; + } + set code(value) { + Object.defineProperty(this, 'code', { + configurable: true, + enumerable: true, + value, + writable: true + }); + } + toString() { + return `${this.name} [${sym}]: ${this.message}`; + } + }; +} +E('ERR_BUFFER_OUT_OF_BOUNDS', function (name) { + if (name) { + return `${name} is outside of buffer bounds`; + } + return 'Attempt to access memory outside buffer bounds'; +}, RangeError); +E('ERR_INVALID_ARG_TYPE', function (name, actual) { + return `The "${name}" argument must be of type number. Received type ${typeof actual}`; +}, TypeError); +E('ERR_OUT_OF_RANGE', function (str, range, input) { + let msg = `The value of "${str}" is out of range.`; + let received = input; + if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) { + received = addNumericalSeparator(String(input)); + } else if (typeof input === 'bigint') { + received = String(input); + if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) { + received = addNumericalSeparator(received); + } + received += 'n'; + } + msg += ` It must be ${range}. Received ${received}`; + return msg; +}, RangeError); +function addNumericalSeparator(val) { + let res = ''; + let i = val.length; + const start = val[0] === '-' ? 1 : 0; + for (; i >= start + 4; i -= 3) { + res = `_${val.slice(i - 3, i)}${res}`; + } + return `${val.slice(0, i)}${res}`; +} + +// CHECK FUNCTIONS +// =============== + +function checkBounds(buf, offset, byteLength) { + validateNumber(offset, 'offset'); + if (buf[offset] === undefined || buf[offset + byteLength] === undefined) { + boundsError(offset, buf.length - (byteLength + 1)); + } +} +function checkIntBI(value, min, max, buf, offset, byteLength) { + if (value > max || value < min) { + const n = typeof min === 'bigint' ? 'n' : ''; + let range; + if (byteLength > 3) { + if (min === 0 || min === BigInt(0)) { + range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`; + } else { + range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` + `${(byteLength + 1) * 8 - 1}${n}`; + } + } else { + range = `>= ${min}${n} and <= ${max}${n}`; + } + throw new errors.ERR_OUT_OF_RANGE('value', range, value); + } + checkBounds(buf, offset, byteLength); +} +function validateNumber(value, name) { + if (typeof value !== 'number') { + throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value); + } +} +function boundsError(value, length, type) { + if (Math.floor(value) !== value) { + validateNumber(value, type); + throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value); + } + if (length < 0) { + throw new errors.ERR_BUFFER_OUT_OF_BOUNDS(); + } + throw new errors.ERR_OUT_OF_RANGE(type || 'offset', `>= ${type ? 1 : 0} and <= ${length}`, value); +} + +// HELPER FUNCTIONS +// ================ + +const 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 utf8ToBytes(string, units) { + units = units || Infinity; + let codePoint; + const length = string.length; + let leadSurrogate = null; + const bytes = []; + for (let 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) { + const byteArray = []; + for (let 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) { + let c, hi, lo; + const byteArray = []; + for (let 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) { + let i; + for (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 +} + +// Create lookup table for `toString('hex')` +// See: https://github.com/feross/buffer/issues/219 +const hexSliceLookupTable = function () { + const alphabet = '0123456789abcdef'; + const table = new Array(256); + for (let i = 0; i < 16; ++i) { + const i16 = i * 16; + for (let j = 0; j < 16; ++j) { + table[i16 + j] = alphabet[i] + alphabet[j]; + } + } + return table; +}(); + +// Return not function with Error if BigInt not supported +function defineBigIntMethod(fn) { + return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn; +} +function BufferBigIntNotDefined() { + throw new Error('BigInt not supported'); +} + +/***/ }, + +/***/ 4406 +(module) { + +"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 _ref of this.match(str)) { + var start = _ref[0]; + var end = _ref[1]; + var tags = _ref[2]; + for (var tag of tags) { + if (typeof actions[tag] === 'function') { + actions[tag](start, end, str.slice(start, end + 1)); + } + } + } + } +} +module.exports = StateMachine; + +/***/ }, + +/***/ 3915 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(8376); +__webpack_require__(6401); +__webpack_require__(2017); +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; +})( false ? 0 : exports); + +/***/ }, + +/***/ 182 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + enumerableOnly && (symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + })), keys.push.apply(keys, symbols); + } + return keys; +} +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = null != arguments[i] ? arguments[i] : {}; + i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { + _defineProperty(target, key, source[key]); + }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + return target; +} +function _defineProperty(obj, key, value) { + key = _toPropertyKey(key); + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; +} +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); +} +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); +} +var _require = __webpack_require__(783), + Buffer = _require.Buffer; +var _require2 = __webpack_require__(3779), + inspect = _require2.inspect; +var custom = inspect && inspect.custom || 'inspect'; +function copyBuffer(src, target, offset) { + Buffer.prototype.copy.call(src, target, offset); +} +module.exports = /*#__PURE__*/function () { + function BufferList() { + _classCallCheck(this, BufferList); + this.head = null; + this.tail = null; + this.length = 0; + } + _createClass(BufferList, [{ + key: "push", + value: function push(v) { + var entry = { + data: v, + next: null + }; + if (this.length > 0) this.tail.next = entry;else this.head = entry; + this.tail = entry; + ++this.length; + } + }, { + key: "unshift", + value: function unshift(v) { + var entry = { + data: v, + next: this.head + }; + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + } + }, { + key: "shift", + value: function shift() { + if (this.length === 0) return; + var ret = this.head.data; + if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; + --this.length; + return ret; + } + }, { + key: "clear", + value: function clear() { + this.head = this.tail = null; + this.length = 0; + } + }, { + key: "join", + value: function join(s) { + if (this.length === 0) return ''; + var p = this.head; + var ret = '' + p.data; + while (p = p.next) ret += s + p.data; + return ret; + } + }, { + key: "concat", + value: function concat(n) { + if (this.length === 0) return Buffer.alloc(0); + var ret = Buffer.allocUnsafe(n >>> 0); + var p = this.head; + var i = 0; + while (p) { + copyBuffer(p.data, ret, i); + i += p.data.length; + p = p.next; + } + return ret; + } + + // Consumes a specified amount of bytes or characters from the buffered data. + }, { + key: "consume", + value: function consume(n, hasStrings) { + var ret; + if (n < this.head.data.length) { + // `slice` is the same for buffers and strings. + ret = this.head.data.slice(0, n); + this.head.data = this.head.data.slice(n); + } else if (n === this.head.data.length) { + // First chunk is a perfect match. + ret = this.shift(); + } else { + // Result spans more than one buffer. + ret = hasStrings ? this._getString(n) : this._getBuffer(n); + } + return ret; + } + }, { + key: "first", + value: function first() { + return this.head.data; + } + + // Consumes a specified amount of characters from the buffered data. + }, { + key: "_getString", + value: function _getString(n) { + var p = this.head; + var c = 1; + var ret = p.data; + n -= ret.length; + while (p = p.next) { + var str = p.data; + var nb = n > str.length ? str.length : n; + if (nb === str.length) ret += str;else ret += str.slice(0, n); + n -= nb; + if (n === 0) { + if (nb === str.length) { + ++c; + if (p.next) this.head = p.next;else this.head = this.tail = null; + } else { + this.head = p; + p.data = str.slice(nb); + } + break; + } + ++c; + } + this.length -= c; + return ret; + } + + // Consumes a specified amount of bytes from the buffered data. + }, { + key: "_getBuffer", + value: function _getBuffer(n) { + var ret = Buffer.allocUnsafe(n); + var p = this.head; + var c = 1; + p.data.copy(ret); + n -= p.data.length; + while (p = p.next) { + var buf = p.data; + var nb = n > buf.length ? buf.length : n; + buf.copy(ret, ret.length - n, 0, nb); + n -= nb; + if (n === 0) { + if (nb === buf.length) { + ++c; + if (p.next) this.head = p.next;else this.head = this.tail = null; + } else { + this.head = p; + p.data = buf.slice(nb); + } + break; + } + ++c; + } + this.length -= c; + return ret; + } + + // Make sure the linked list only shows the minimal necessary information. + }, { + key: custom, + value: function value(_, options) { + return inspect(this, _objectSpread(_objectSpread({}, options), {}, { + // Only inspect one level. + depth: 0, + // It should not recurse. + customInspect: false + })); + } + }]); + return BufferList; +}(); + +/***/ }, + +/***/ 5691 +(module, exports, __webpack_require__) { + +"use strict"; + + +/* eslint-disable node/no-deprecated-api */ +var buffer = __webpack_require__(783); +var Buffer = buffer.Buffer; + +// alternative to using Object.keys for old browsers +function copyProps(src, dst) { + for (var key in src) { + dst[key] = src[key]; + } +} +if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { + module.exports = buffer; +} else { + // Copy properties from require('buffer') + copyProps(buffer, exports); + exports.Buffer = SafeBuffer; +} +function SafeBuffer(arg, encodingOrOffset, length) { + return Buffer(arg, encodingOrOffset, length); +} + +// Copy static methods from Buffer +copyProps(Buffer, SafeBuffer); +SafeBuffer.from = function (arg, encodingOrOffset, length) { + if (typeof arg === 'number') { + throw new TypeError('Argument must not be a number'); + } + return Buffer(arg, encodingOrOffset, length); +}; +SafeBuffer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number'); + } + var buf = Buffer(size); + if (fill !== undefined) { + if (typeof encoding === 'string') { + buf.fill(fill, encoding); + } else { + buf.fill(fill); + } + } else { + buf.fill(0); + } + return buf; +}; +SafeBuffer.allocUnsafe = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number'); + } + return Buffer(size); +}; +SafeBuffer.allocUnsafeSlow = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number'); + } + return buffer.SlowBuffer(size); +}; + +/***/ }, + +/***/ 7571 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(8376); +__webpack_require__(6401); +__webpack_require__(2017); +const inflate = __webpack_require__(3483); +const _require = __webpack_require__(6016), + swap32LE = _require.swap32LE; + +// 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 + var _data = data; + this.data = _data.data; + this.highStart = _data.highStart; + this.errorValue = _data.errorValue; + } + } + 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; + +/***/ }, + +/***/ 6016 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +__webpack_require__(8376); +__webpack_require__(6401); +__webpack_require__(2017); +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 +}; + +/***/ }, + +/***/ 3215 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +var __webpack_unused_export__; +var __webpack_dirname__ = "/"; +/* provided dependency */ var Buffer = __webpack_require__(783)["Buffer"]; + + +__webpack_unused_export__ = ({ + value: true +}); +exports.A = void 0; +__webpack_require__(187); +__webpack_require__(8376); +__webpack_require__(6401); +__webpack_require__(2017); +var _stream = _interopRequireDefault(__webpack_require__(9760)); +var _zlib = _interopRequireDefault(__webpack_require__(6729)); +var _utils = __webpack_require__(3973); +var _jsMd = _interopRequireDefault(__webpack_require__(1632)); +var _sha = __webpack_require__(7785); +var _aes = __webpack_require__(2651); +var fontkit = _interopRequireWildcard(__webpack_require__(1715)); +var _events = __webpack_require__(4785); +var _linebreak = _interopRequireDefault(__webpack_require__(2532)); +var _pngJs = _interopRequireDefault(__webpack_require__(381)); +function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } +function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; } +var fs = __webpack_require__(2416); +class PDFAbstractReference { + toString() { + throw new Error('Must be implemented by subclasses'); + } +} +class PDFTree { + constructor() { + let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + 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', 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 pad = (str, length) => (Array(length + 1).join('0') + str).slice(-length); +const escapableRe = /[\n\r\t\b\f()\\]/g; +const escapable = { + '\n': '\\n', + '\r': '\\r', + '\t': '\\t', + '\b': '\\b', + '\f': '\\f', + '\\': '\\\\', + '(': '\\(', + ')': '\\)' +}; +const swapBytes = function (buff) { + const l = buff.length; + if (l & 0x01) { + throw new Error('Buffer length must be even'); + } else { + for (let i = 0, end = l - 1; i < end; i += 2) { + const a = buff[i]; + buff[i] = buff[i + 1]; + buff[i + 1] = a; + } + } + return buff; +}; +class PDFObject { + static convert(object) { + let encryptFn = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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 stringBuffer; + if (isUnicode) { + stringBuffer = swapBytes(Buffer.from(`\ufeff${string}`, 'utf16le')); + } else { + stringBuffer = Buffer.from(string.valueOf(), 'ascii'); + } + if (encryptFn) { + string = encryptFn(stringBuffer).toString('binary'); + } else { + string = stringBuffer.toString('binary'); + } + string = string.replace(escapableRe, c => escapable[c]); + return `(${string})`; + } else if (Buffer.isBuffer(object)) { + return `<${object.toString('hex')}>`; + } 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 = encryptFn(Buffer.from(string, 'ascii')).toString('binary'); + string = string.replace(escapableRe, c => escapable[c]); + } + return `(${string})`; + } else if (Array.isArray(object)) { + const items = object.map(e => PDFObject.convert(e, encryptFn)).join(' '); + return `[${items}]`; + } else if ({}.toString.call(object) === '[object Object]') { + const out = ['<<']; + for (let key in object) { + const val = object[key]; + 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}`); + } +} +class PDFReference extends PDFAbstractReference { + constructor(document, id) { + let data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + 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 = Buffer.from(chunk + '\n', 'binary'); + } + 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 = Buffer.concat(this.buffer); + if (this.compress) { + this.buffer = _zlib.default.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) { + let defaultDefinition = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined; + let transformer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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(); + if (options.font) document.font(options.font, options.fontFamily); + if (options.fontSize) document.fontSize(options.fontSize); + 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 md5Hash(data) { + return new Uint8Array(_jsMd.default.arrayBuffer(data)); +} +function md5Hex(data) { + return (0, _jsMd.default)(data); +} +function sha256Hash(data) { + return (0, _sha.sha256)(data); +} +function aesCbcEncrypt(data, key, iv) { + let padding = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + return (0, _aes.cbc)(key, iv, { + disablePadding: !padding + }).encrypt(data); +} +function aesEcbEncrypt(data, key) { + return (0, _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; + var _ref3 = [s[j], s[i]]; + s[i] = _ref3[0]; + s[j] = _ref3[1]; + } + 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; + var _ref4 = [s[j], s[i]]; + s[i] = _ref4[0]; + s[j] = _ref4[1]; + output[k] = data[k] ^ s[s[i] + s[j] & 0xff]; + } + return output; +} +function randomBytes(length) { + const bytes = new Uint8Array(length); + if (globalThis.crypto?.getRandomValues) { + globalThis.crypto.getRandomValues(bytes); + } else { + (__webpack_require__(5470).randomFillSync)(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) { + let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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() { + let info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + let infoStr = `${info.CreationDate.getTime()}\n`; + for (let key in info) { + if (!info.hasOwnProperty(key)) { + continue; + } + infoStr += `${key}: ${info[key].valueOf()}\n`; + } + return Buffer.from(md5Hash(infoStr)); + } + static generateRandomWordArray(bytes) { + return randomBytes(bytes); + } + static create(document) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + if (!options.ownerPassword && !options.userPassword) { + return null; + } + return new PDFSecurity(document, options); + } + constructor(document) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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 = Buffer.from(ownerPasswordEntry); + encDict.U = Buffer.from(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 = Buffer.from(ownerPasswordEntry); + encDict.OE = Buffer.from(ownerEncryptionKeyEntry); + encDict.U = Buffer.from(userPasswordEntry); + encDict.UE = Buffer.from(userEncryptionKeyEntry); + encDict.P = permissions; + encDict.Perms = Buffer.from(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 = (0, _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 => Buffer.from(rc4(new Uint8Array(buffer), key)); + } + let key; + if (this.version === 4) { + const saltMarker = new Uint8Array([0x73, 0x41, 0x6c, 0x54]); + key = md5Hash((0, _utils.concatBytes)(digest, saltMarker)); + } else { + key = this.encryptionKey; + } + const iv = PDFSecurity.generateRandomWordArray(16); + return buffer => { + const encrypted = aesCbcEncrypt(new Uint8Array(buffer), key, iv, true); + return Buffer.from((0, _utils.concatBytes)(iv, encrypted)); + }; + } + end() { + this.dictionary.end(); + } +} +function getPermissionsR2() { + let permissionObject = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + 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() { + let permissionObject = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + 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((0, _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 = (0, _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((0, _utils.concatBytes)(processedUserPassword, validationSalt)); + return (0, _utils.concatBytes)(hash, validationSalt, keySalt); +} +function getUserEncryptionKeyR5(processedUserPassword, userKeySalt, encryptionKey) { + const key = sha256Hash((0, _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((0, _utils.concatBytes)(processedOwnerPassword, validationSalt, userPasswordEntry)); + return (0, _utils.concatBytes)(hash, validationSalt, keySalt); +} +function getOwnerEncryptionKeyR5(processedOwnerPassword, ownerKeySalt, userPasswordEntry, encryptionKey) { + const key = sha256Hash((0, _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() { + let password = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + 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() { + let password = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + 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$2 = PDFObject.number; +class PDFGradient$1 { + 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 _this$doc$_ctm = this.doc._ctm, + m0 = _this$doc$_ctm[0], + m1 = _this$doc$_ctm[1], + m2 = _this$doc$_ctm[2], + m3 = _this$doc$_ctm[3], + m4 = _this$doc$_ctm[4], + m5 = _this$doc$_ctm[5]; + const _this$transform = this.transform, + m11 = _this$transform[0], + m12 = _this$transform[1], + m21 = _this$transform[2], + m22 = _this$transform[3], + dx = _this$transform[4], + dy = _this$transform[5]; + 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}`); + } +} +class PDFLinearGradient$1 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$1(this.doc, this.x1, this.y1, this.x2, this.y2); + } +} +class PDFRadialGradient$1 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$1(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']; +class PDFTilingPattern$1 { + 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 _this$doc$_ctm2 = this.doc._ctm, + m0 = _this$doc$_ctm2[0], + m1 = _this$doc$_ctm2[1], + m2 = _this$doc$_ctm2[2], + m3 = _this$doc$_ctm2[3], + m4 = _this$doc$_ctm2[4], + m5 = _this$doc$_ctm2[5]; + const m11 = 1, + m12 = 0, + m21 = 0, + m22 = 1, + dx = 0, + dy = 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 = Gradient.PDFGradient, + PDFLinearGradient = Gradient.PDFLinearGradient, + PDFRadialGradient = Gradient.PDFRadialGradient; +const PDFTilingPattern = pattern.PDFTilingPattern; +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]) { + var _this$_opacityRegistr = this._opacityRegistry[key]; + dictionary = _this$_opacityRegistr[0]; + name = _this$_opacityRegistr[1]; + } 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 !== '-') { + var _readNumber = readNumber(path, i); + newCursor = _readNumber[0]; + number = _readNumber[1]; + } + } + if (position === 2 || position === 5 || position === 6) { + var _readNumber2 = readNumber(path, i); + newCursor = _readNumber2[0]; + number = _readNumber2[1]; + } + if (position === 3 || position === 4) { + if (c === '0') { + number = 0; + } + if (c === '1') { + number = 1; + } + } + } else { + var _readNumber3 = readNumber(path, i); + newCursor = _readNumber3[0]; + number = _readNumber3[1]; + } + 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 = coords[0], + ry = coords[1], + rot = coords[2], + large = coords[3], + sweep = coords[4], + ex = coords[5], + ey = coords[6]; + 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$1 = PDFObject.number; +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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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, r) { + if (r == null) { + r = 0; + } + r = Math.min(r, 0.5 * w, 0.5 * h); + const c = r * (1.0 - KAPPA); + this.moveTo(x + r, y); + this.lineTo(x + w - r, y); + this.bezierCurveTo(x + w - c, y, x + w, y + c, x + w, y + r); + this.lineTo(x + w, y + h - r); + this.bezierCurveTo(x + w, y + h - c, x + w - c, y + h, x + w - r, y + h); + this.lineTo(x + r, y + h); + this.bezierCurveTo(x + c, y + h, x, y + h - c, x, y + h - r); + this.lineTo(x, y + r); + this.bezierCurveTo(x, y + c, x + c, y, x + r, 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() { + for (var _len = arguments.length, points = new Array(_len), _key = 0; _key < _len; _key++) { + points[_key] = arguments[_key]; + } + 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 = m[0], + m1 = m[1], + m2 = m[2], + m3 = m[3], + m4 = m[4], + m5 = m[5]; + 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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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) { + var _options$origin = options.origin; + x = _options$origin[0]; + y = _options$origin[1]; + 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) { + let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + let y; + if (yFactor == null) { + yFactor = xFactor; + } + if (typeof yFactor === 'object') { + options = yFactor; + yFactor = xFactor; + } + let x = y = 0; + if (options.origin != null) { + var _options$origin2 = options.origin; + x = _options$origin2[0]; + y = _options$origin2[1]; + x -= xFactor * x; + y -= yFactor * y; + } + return this.transform(xFactor, 0, 0, yFactor, x, y); + } +}; +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(contents) { + this.attributes = {}; + this.glyphWidths = {}; + this.boundingBoxes = {}; + this.kernPairs = {}; + this.parse(contents); + this.bbox = this.attributes['FontBBox'].split(/\s+/).map(e => +e); + this.ascender = +(this.attributes['Ascender'] || 0); + this.descender = +(this.attributes['Descender'] || 0); + this.xHeight = +(this.attributes['XHeight'] || 0); + this.capHeight = +(this.attributes['CapHeight'] || 0); + this.lineGap = this.bbox[3] - this.bbox[1] - (this.ascender - this.descender); + } + parse(contents) { + let section = ''; + for (let line of contents.split('\n')) { + var match; + var a; + if (match = line.match(/^Start(\w+)/)) { + section = match[1]; + continue; + } else if (match = line.match(/^End(\w+)/)) { + section = ''; + continue; + } + switch (section) { + case 'FontMetrics': + match = line.match(/(^\w+)\s+(.*)/); + var key = match[1]; + var value = match[2]; + if (a = this.attributes[key]) { + if (!Array.isArray(a)) { + a = this.attributes[key] = [a]; + } + a.push(value); + } else { + this.attributes[key] = value; + } + break; + case 'CharMetrics': + if (!/^CH?\s/.test(line)) { + continue; + } + var name = line.match(/\bN\s+(\.?\w+)\s*;/)[1]; + this.glyphWidths[name] = +line.match(/\bWX\s+(\d+)\s*;/)[1]; + break; + case 'KernPairs': + match = line.match(/^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/); + if (match) { + this.kernPairs[match[1] + '\0' + match[2]] = parseInt(match[3]); + } + break; + } + } + } + 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) { + let includeGap = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + const gap = includeGap ? this.lineGap : 0; + return (this.ascender + gap - this.descender) / 1000 * size; + } +} +const STANDARD_FONTS = { + Courier() { + return fs.readFileSync(__webpack_dirname__ + '/data/Courier.afm', 'utf8'); + }, + 'Courier-Bold'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Courier-Bold.afm', 'utf8'); + }, + 'Courier-Oblique'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Courier-Oblique.afm', 'utf8'); + }, + 'Courier-BoldOblique'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Courier-BoldOblique.afm', 'utf8'); + }, + Helvetica() { + return fs.readFileSync(__webpack_dirname__ + '/data/Helvetica.afm', 'utf8'); + }, + 'Helvetica-Bold'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Helvetica-Bold.afm', 'utf8'); + }, + 'Helvetica-Oblique'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Helvetica-Oblique.afm', 'utf8'); + }, + 'Helvetica-BoldOblique'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Helvetica-BoldOblique.afm', 'utf8'); + }, + 'Times-Roman'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Times-Roman.afm', 'utf8'); + }, + 'Times-Bold'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Times-Bold.afm', 'utf8'); + }, + 'Times-Italic'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Times-Italic.afm', 'utf8'); + }, + 'Times-BoldItalic'() { + return fs.readFileSync(__webpack_dirname__ + '/data/Times-BoldItalic.afm', 'utf8'); + }, + Symbol() { + return fs.readFileSync(__webpack_dirname__ + '/data/Symbol.afm', 'utf8'); + }, + ZapfDingbats() { + return fs.readFileSync(__webpack_dirname__ + '/data/ZapfDingbats.afm', 'utf8'); + } +}; +class StandardFont extends PDFFont { + constructor(document, name, id) { + super(); + this.document = document; + this.name = name; + this.id = id; + this.font = new AFMFont(STANDARD_FONTS[this.name]()); + var _this$font = this.font; + this.ascender = _this$font.ascender; + this.descender = _this$font.descender; + this.bbox = _this$font.bbox; + this.lineGap = _this$font.lineGap; + this.xHeight = _this$font.xHeight; + this.capHeight = _this$font.capHeight; + } + 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; + } + static isStandardFont(name) { + return name in STANDARD_FONTS; + } +} +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 _this$layout = this.layout(text, features), + glyphs = _this$layout.glyphs, + positions = _this$layout.positions; + 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.bbox; + 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 CIDSet = Buffer.from('FFFFFFFFC0', 'hex'); + const CIDSetRef = this.document.ref(); + CIDSetRef.write(CIDSet); + 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> +endcodespacerange +${ranges.length} beginbfrange +${ranges.join('\n')} +endbfrange +endcmap +CMapName currentdict /CMap defineresource pop +end +end\ +`); + return cmap; + } +} +class PDFFontFactory { + static open(document, src, family, id) { + let font; + if (typeof src === 'string') { + if (StandardFont.isStandardFont(src)) { + return new StandardFont(document, 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() { + let defaultFont = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Helvetica'; + let defaultFontFamily = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + let defaultFontSize = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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; + var _this$_registeredFont = this._registeredFonts[src]; + src = _this$_registeredFont.src; + family = _this$_registeredFont.family; + } 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._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) { + let defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + let page = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.page; + let percentageWidth = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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 _events.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.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 indent = this.continuedX || this.indent; + this.document.x += indent; + this.lineWidth -= indent; + if (options.indentAllLines) { + return; + } + this.once('line', () => { + this.document.x -= indent; + this.lineWidth += indent; + if (options.continued && !this.continuedX) { + this.continuedX = this.indent; + } + if (!options.continued) { + this.continuedX = 0; + } + }); + }); + this.on('lastLine', options => { + const align = options.align; + 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 _linebreak.default(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) { + 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 = this.document.y + this.document.currentLineHeight(true); + if (this.document.y > this.maxY || nextY > this.maxY) { + this.nextSection(); + } + let buffer = ''; + let textWidth = 0; + let wc = 0; + let lc = 0; + let y = this.document.y; + const emitLine = () => { + options.textWidth = textWidth + this.wordSpacing * (wc - 1); + options.wordCount = wc; + options.lineWidth = this.lineWidth; + y = this.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 = this.document.currentLineHeight(true); + if (this.height != null && this.ellipsis && PDFNumber(this.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(this.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; + this.document.y = y; + } else { + this.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) { + const indent = this.continuedX || this.indent; + this.document.x += indent; + this.lineWidth -= 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.number; +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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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 = this.x; + y = this.y; + 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 = this.x, + y = this.y; + 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) { + var _options$structTypes = options.structTypes; + itemType = _options$structTypes[0]; + labelType = _options$structTypes[1]; + bodyType = _options$structTypes[2]; + } else { + itemType = 'LI'; + labelType = 'Lbl'; + bodyType = '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() { + let x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + let y = arguments.length > 1 ? arguments[1] : undefined; + let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + if (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(options.rotation ?? 0) % 360; + if (result.rotation < 0) result.rotation += 360; + return result; + }, + _line(text) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + let wrapper = arguments.length > 2 ? arguments[2] : undefined; + 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 _this$_font$encode = this._font.encode(word, options.features), + encodedWord = _this$_font$encode[0], + positionsWord = _this$_font$encode[1]; + 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 { + var _this$_font$encode2 = this._font.encode(text, options.features); + encoded = _this$_font$encode2[0]; + positions = _this$_font$encode2[1]; + } + 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 = data.readUInt16BE(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 = data.readUInt16BE(pos); + if (marker === 0xffe1 && pos + 8 <= data.length) { + const exifHeader = data.subarray(pos + 2, pos + 8).toString('binary'); + if (exifHeader === 'Exif\x00\x00') { + const tiffStart = pos + 8; + if (tiffStart + 8 > data.length) return null; + const byteOrder = data.subarray(tiffStart, tiffStart + 2).toString('ascii'); + const isLittleEndian = byteOrder === 'II'; + if (!isLittleEndian && byteOrder !== 'MM') return null; + const read16 = isLittleEndian ? o => data.readUInt16LE(o) : o => data.readUInt16BE(o); + const read32 = isLittleEndian ? o => data.readUInt32LE(o) : o => data.readUInt32BE(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 (this.data.readUInt16BE(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 = this.data.readUInt16BE(pos); + pos += 2; + if (MARKERS.includes(marker)) { + break; + } + pos += this.data.readUInt16BE(pos); + } + if (!MARKERS.includes(marker)) { + throw 'Invalid JPEG.'; + } + pos += 2; + this.bits = this.data[pos++]; + this.height = this.data.readUInt16BE(pos); + pos += 2; + this.width = this.data.readUInt16BE(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 _pngJs.default(data); + this.width = this.image.width; + this.height = this.image.height; + this.imgData = this.image.imgData; + this.obj = null; + } + embed(document) { + let dataDecoded = false; + this.document = document; + if (this.obj) { + return; + } + const hasAlphaChannel = this.image.hasAlphaChannel; + const isInterlaced = this.image.interlaceMethod === 1; + this.obj = this.document.ref({ + Type: 'XObject', + Subtype: 'Image', + BitsPerComponent: hasAlphaChannel ? 8 : this.image.bits, + Width: this.width, + Height: this.height, + Filter: 'FlateDecode' + }); + if (!hasAlphaChannel) { + const params = this.document.ref({ + Predictor: isInterlaced ? 1 : 15, + Colors: this.image.colors, + BitsPerComponent: this.image.bits, + Columns: this.width + }); + this.obj.data['DecodeParms'] = params; + params.end(); + } + if (this.image.palette.length === 0) { + this.obj.data['ColorSpace'] = this.image.colorSpace; + } else { + const palette = this.document.ref(); + palette.end(Buffer.from(this.image.palette)); + this.obj.data['ColorSpace'] = ['Indexed', 'DeviceRGB', this.image.palette.length / 3 - 1, palette]; + } + if (this.image.transparency.grayscale != null) { + const val = this.image.transparency.grayscale; + this.obj.data['Mask'] = [val, val]; + } else if (this.image.transparency.rgb) { + const rgb = this.image.transparency.rgb; + const mask = []; + for (let x of rgb) { + mask.push(x, x); + } + this.obj.data['Mask'] = mask; + } else if (this.image.transparency.indexed) { + dataDecoded = true; + return this.loadIndexedAlphaChannel(); + } else if (hasAlphaChannel) { + dataDecoded = true; + return this.splitAlphaChannel(); + } + if (isInterlaced && !dataDecoded) { + 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 = Buffer.alloc(pixelCount * colorCount); + const alphaChannel = Buffer.alloc(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.default.deflateSync(imgData); + this.alphaChannel = _zlib.default.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 = Buffer.alloc(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.default.deflateSync(Buffer.from(pixels)); + } + this.alphaChannel = _zlib.default.deflateSync(alphaChannel); + return this.finalize(); + }); + } + decodeData() { + this.image.decodePixels(pixels => { + this.imgData = _zlib.default.deflateSync(pixels); + this.finalize(); + }); + } +} +class PDFImage { + static open(src, label) { + let data; + if (Buffer.isBuffer(src)) { + data = src; + } else if (src instanceof ArrayBuffer) { + data = Buffer.from(new Uint8Array(src)); + } else { + const match = /^data:.+?;base64,(.*)$/.exec(src); + if (match) { + data = Buffer.from(match[1], 'base64'); + } 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.toString('ascii', 1, 4) === 'PNG') { + return new PNGImage(data, label); + } else { + throw new Error('Unknown image format.'); + } + } +} +var ImagesMixin = { + initImages() { + this._imageRegistry = {}; + this._imageCount = 0; + }, + image(src, x, y) { + let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {}; + 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 _image = image, + width = _image.width, + height = _image.height; + if (!ignoreOrientation && image.orientation > 4) { + var _ref5 = [height, width]; + width = _ref5[0]; + height = _ref5[1]; + } + 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) { + var _options$fit = options.fit; + bw = _options$fit[0]; + bh = _options$fit[1]; + bp = bw / bh; + ip = width / height; + if (ip > bp) { + w = bw; + h = bw / ip; + } else { + h = bh; + w = bh * ip; + } + } else if (options.cover) { + var _options$cover = options.cover; + bw = _options$cover[0]; + bh = _options$cover[1]; + 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 (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) { + options.Type = 'Annot'; + options.Rect = this._convertRect(x, y, w, h); + options.Border = [0, 0, 0]; + if (options.Subtype === 'Link' && typeof options.F === 'undefined') { + options.F = 1 << 2; + } + if (options.Subtype !== 'Link') { + if (options.C == null) { + options.C = this._normalizeColor(options.color || [0, 0, 0]); + } + } + delete options.color; + if (typeof options.Dest === 'string') { + options.Dest = new String(options.Dest); + } + const structParent = options.structParent; + delete options.structParent; + for (let key in options) { + const val = options[key]; + options[key[0].toUpperCase() + key.slice(1)] = val; + } + const ref = this.ref(options); + this.page.annotations.push(ref); + if (structParent && typeof structParent.add === 'function') { + const annotRef = new PDFAnnotationReference(ref); + structParent.add(annotRef); + } + ref.end(); + return this; + }, + note(x, y, w, h, contents) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + options.Subtype = 'Text'; + options.Contents = new String(contents); + if (options.Name == null) { + options.Name = 'Comment'; + } + if (options.color == null) { + options.color = [243, 223, 92]; + } + return this.annotate(x, y, w, h, options); + }, + goTo(x, y, w, h, name) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + options.Subtype = 'Link'; + options.A = this.ref({ + S: 'GoTo', + D: new String(name) + }); + options.A.end(); + return this.annotate(x, y, w, h, options); + }, + link(x, y, w, h, url) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + options.Subtype = 'Link'; + if (typeof url === 'number') { + const pages = this._root.data.Pages.data; + if (url >= 0 && url < pages.Kids.length) { + options.A = this.ref({ + S: 'GoTo', + D: [pages.Kids[url], 'XYZ', null, null, null] + }); + options.A.end(); + } else { + throw new Error(`The document has no page ${url}`); + } + } else { + options.A = this.ref({ + S: 'URI', + URI: new String(url) + }); + options.A.end(); + } + if (options.structParent && !options.Contents) { + options.Contents = new String(''); + } + return this.annotate(x, y, w, h, options); + }, + _markup(x, y, w, h) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + const _this$_convertRect = this._convertRect(x, y, w, h), + x1 = _this$_convertRect[0], + y1 = _this$_convertRect[1], + x2 = _this$_convertRect[2], + y2 = _this$_convertRect[3]; + options.QuadPoints = [x1, y2, x2, y2, x1, y1, x2, y1]; + options.Contents = new String(); + return this.annotate(x, y, w, h, options); + }, + highlight(x, y, w, h) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + options.Subtype = 'Highlight'; + if (options.color == null) { + options.color = [241, 238, 148]; + } + return this._markup(x, y, w, h, options); + }, + underline(x, y, w, h) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + options.Subtype = 'Underline'; + return this._markup(x, y, w, h, options); + }, + strike(x, y, w, h) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + options.Subtype = 'StrikeOut'; + return this._markup(x, y, w, h, options); + }, + lineAnnotation(x1, y1, x2, y2) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + options.Subtype = 'Line'; + options.Contents = new String(); + options.L = [x1, this.page.height - y1, x2, this.page.height - y2]; + return this.annotate(x1, y1, x2, y2, options); + }, + rectAnnotation(x, y, w, h) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + options.Subtype = 'Square'; + options.Contents = new String(); + return this.annotate(x, y, w, h, options); + }, + ellipseAnnotation(x, y, w, h) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + options.Subtype = 'Circle'; + options.Contents = new String(); + return this.annotate(x, y, w, h, options); + }, + textAnnotation(x, y, w, h, text) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + options.Subtype = 'FreeText'; + options.Contents = new String(text); + options.DA = new String(); + return this.annotate(x, y, w, h, options); + }, + fileAnnotation(x, y, w, h) { + let file = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}; + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + const filespec = this.file(file.src, Object.assign({ + hidden: true + }, file)); + options.Subtype = 'FileAttachment'; + options.FS = filespec; + if (options.Contents) { + options.Contents = new String(options.Contents); + } else if (filespec.data.Desc) { + options.Contents = filespec.data.Desc; + } + return this.annotate(x, y, w, h, options); + }, + _convertRect(x1, y1, w, h) { + let y2 = y1; + y1 += h; + let x2 = x1 + w; + const _this$_ctm = this._ctm, + m0 = _this$_ctm[0], + m1 = _this$_ctm[1], + m2 = _this$_ctm[2], + m3 = _this$_ctm[3], + m4 = _this$_ctm[4], + m5 = _this$_ctm[5]; + 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) { + let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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) { + let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + let children = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 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 (typeof options.title !== 'undefined') { + data.T = new String(options.title); + } + if (typeof options.lang !== 'undefined') { + data.Lang = new String(options.lang); + } + if (typeof options.alt !== 'undefined') { + data.Alt = new String(options.alt); + } + if (typeof options.expanded !== 'undefined') { + data.E = new String(options.expanded); + } + if (typeof options.actual !== 'undefined') { + data.ActualText = new String(options.actual); + } + 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(_ref => { + let pageRef = _ref.pageRef, + mcid = _ref.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(_ref2 => { + let pageRef = _ref2.pageRef, + mcid = _ref2.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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + let children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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 + } +}; +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) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + let fieldDict = this._fieldDict(name, null, options); + let fieldRef = this.ref(fieldDict); + this._addToParent(fieldRef); + return fieldRef; + }, + formAnnotation(name, type, x, y, w, h) { + let options = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {}; + 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) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + return this.formAnnotation(name, 'text', x, y, w, h, options); + }, + formPushButton(name, x, y, w, h) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + return this.formAnnotation(name, 'pushButton', x, y, w, h, options); + }, + formCombo(name, x, y, w, h) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + return this.formAnnotation(name, 'combo', x, y, w, h, options); + }, + formList(name, x, y, w, h) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + return this.formAnnotation(name, 'list', x, y, w, h, options); + }, + formRadioButton(name, x, y, w, h) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + return this.formAnnotation(name, 'radioButton', x, y, w, h, options); + }, + formCheckbox(name, x, y, w, h) { + let options = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}; + 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) { + let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + if (!this._acroform) { + throw new Error('Call document.initForm() method before adding form elements to document'); + } + let opts = Object.assign({}, options); + if (type !== null) { + opts = this._resolveType(type, options); + } + opts = this._resolveFlags(opts); + opts = this._resolveJustify(opts); + opts = this._resolveFont(opts); + opts = this._resolveStrings(opts); + opts = this._resolveColors(opts); + opts = this._resolveFormat(opts); + opts.T = new String(name); + if (opts.parent) { + opts.Parent = opts.parent; + delete opts.parent; + } + return opts; + }, + _resolveType(type, opts) { + if (type === 'text') { + opts.FT = 'Tx'; + } else if (type === 'pushButton') { + opts.FT = 'Btn'; + opts.pushButton = true; + } else if (type === 'radioButton') { + opts.FT = 'Btn'; + opts.radioButton = true; + } else if (type === 'checkbox') { + opts.FT = 'Btn'; + } else if (type === 'combo') { + opts.FT = 'Ch'; + opts.combo = true; + } else if (type === 'list') { + opts.FT = 'Ch'; + } else { + throw new Error(`Invalid form annotation type '${type}'`); + } + return opts; + }, + _resolveFormat(opts) { + const f = opts.format; + if (f && 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'; + 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(',')); + } + } + opts.AA = opts.AA ? opts.AA : {}; + opts.AA.K = { + S: 'JavaScript', + JS: new String(`${fnKeystroke}(${params});`) + }; + opts.AA.F = { + S: 'JavaScript', + JS: new String(`${fnFormat}(${params});`) + }; + } + delete opts.format; + return opts; + }, + _resolveColors(opts) { + let color = this._normalizeColor(opts.backgroundColor); + if (color) { + if (!opts.MK) { + opts.MK = {}; + } + opts.MK.BG = color; + } + color = this._normalizeColor(opts.borderColor); + if (color) { + if (!opts.MK) { + opts.MK = {}; + } + opts.MK.BC = color; + } + delete opts.backgroundColor; + delete opts.borderColor; + return opts; + }, + _resolveFlags(options) { + let result = 0; + Object.keys(options).forEach(key => { + if (FIELD_FLAGS[key]) { + if (options[key]) { + result |= FIELD_FLAGS[key]; + } + delete options[key]; + } + }); + if (result !== 0) { + options.Ff = options.Ff ? options.Ff : 0; + options.Ff |= result; + } + return options; + }, + _resolveJustify(options) { + let result = 0; + if (options.align !== undefined) { + if (typeof FIELD_JUSTIFY[options.align] === 'number') { + result = FIELD_JUSTIFY[options.align]; + } + delete options.align; + } + if (result !== 0) { + options.Q = result; + } + return options; + }, + _resolveFont(options) { + if (this._acroform.fonts[this._font.id] == null) { + this._acroform.fonts[this._font.id] = this._font.ref(); + } + if (this._acroform.defaultFont !== this._font.name) { + options.DR = { + Font: {} + }; + const fontSize = options.fontSize || 0; + options.DR.Font[this._font.id] = this._font.ref(); + options.DA = new String(`/${this._font.id} ${fontSize} Tf 0 g`); + } + return options; + }, + _resolveStrings(options) { + let select = []; + function appendChoices(a) { + if (Array.isArray(a)) { + for (let idx = 0; idx < a.length; idx++) { + if (typeof a[idx] === 'string') { + select.push(new String(a[idx])); + } else { + select.push(a[idx]); + } + } + } + } + appendChoices(options.Opt); + if (options.select) { + appendChoices(options.select); + delete options.select; + } + if (select.length) { + options.Opt = select; + } + Object.keys(VALUE_MAP).forEach(key => { + if (options[key] !== undefined) { + options[VALUE_MAP[key]] = options[key]; + delete options[key]; + } + }); + ['V', 'DV'].forEach(key => { + if (typeof options[key] === 'string') { + options[key] = new String(options[key]); + } + }); + if (options.MK && options.MK.CA) { + options.MK.CA = new String(options.MK.CA); + } + if (options.label) { + options.MK = options.MK ? options.MK : {}; + options.MK.CA = new String(options.label); + delete options.label; + } + return options; + } +}; +var AttachmentsMixin = { + file(src) { + let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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 (Buffer.isBuffer(src)) { + data = src; + } else if (src instanceof ArrayBuffer) { + data = Buffer.from(new Uint8Array(src)); + } else { + const match = /^data:(.*?);base64,(.*)$/.exec(src); + if (match) { + if (match[1]) { + refBody.Subtype = match[1].replace('/', '#2F'); + } + data = Buffer.from(match[2], 'base64'); + } else { + data = fs.readFileSync(src); + if (!data) { + throw new Error(`Could not read contents of file at filepath ${src}`); + } + const _fs$statSync = fs.statSync(src), + birthtime = _fs$statSync.birthtime, + ctime = _fs$statSync.ctime; + 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 = options.type.replace('/', '#2F'); + } + 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()); +} +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() { + const iccProfile = Buffer("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", "base64"); + ; + 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 ` + + ${this.subset} + ${this.subset_conformance} + + `; + }, + _addPdfaMetadata() { + this.appendXML(this._getPdfaid()); + } +}; +var PDFUA = { + initPDFUA() { + this.subset = 1; + }, + endSubset() { + this._addPdfuaMetadata(); + }, + _addPdfuaMetadata() { + this.appendXML(this._getPdfuaid()); + }, + _getPdfuaid() { + return ` + + ${this.subset} + + `; + } +}; +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 () { + const key = arguments.length <= 0 ? undefined : arguments[0]; + if (!cache.has(key)) { + cache.set(key, fn(...arguments)); + 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) { + if (!isObject(target)) return target; + target = deepClone(target); + for (var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + sources[_key - 1] = arguments[_key]; + } + 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(_ref => { + let k = _ref[0]; + return ROW_FIELDS.includes(k); + })); + const defaultColStyle = Object.fromEntries(Object.entries(defaultStyle).filter(_ref2 => { + let k = _ref2[0]; + return 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 _normalizedDefaultSty = normalizedDefaultStyle(opts.defaultStyle), + defaultStyle = _normalizedDefaultSty.defaultStyle, + defaultColStyle = _normalizedDefaultSty.defaultColStyle, + defaultRowStyle = _normalizedDefaultSty.defaultRowStyle; + 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 = deepMerge({}, colStyle.font, rowStyle.font, cell.font); + 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 _computeBounds = computeBounds(rotation, textAllocatedWidth, textAllocatedHeight), + textMaxWidth = _computeBounds.width, + textMaxHeight = _computeBounds.height; + 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(_ref => { + let k = _ref[0], + v = _ref[1]; + return [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) { + let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + 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) { + let lastRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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 _measure$call = measure.call(this, row, this._currRowIndex), + newPage = _measure$call.newPage, + toRender = _measure$call.toRender; + 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 = ` + + + + `; + } + _closeTags() { + this._metadata = this._metadata.concat(` + + + + `); + } + append(xml) { + let newline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 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) { + let newline = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + this.metadata.append(xml, newline); + }, + _addInfo() { + this.appendXML(` + + ${this.info.CreationDate.toISOString().split('.')[0] + 'Z'} + ${this.info.Creator} + + `); + if (this.info.Title || this.info.Author || this.info.Subject) { + this.appendXML(` + + `); + if (this.info.Title) { + this.appendXML(` + + + ${this.info.Title} + + + `); + } + if (this.info.Author) { + this.appendXML(` + + + ${this.info.Author} + + + `); + } + if (this.info.Subject) { + this.appendXML(` + + + ${this.info.Subject} + + + `); + } + this.appendXML(` + + `); + } + this.appendXML(` + + ${this.info.Creator}`, false); + if (this.info.Keywords) { + this.appendXML(` + ${this.info.Keywords}`, false); + } + this.appendXML(` + + `); + }, + 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(Buffer.from(this.metadata.getXML(), 'utf-8')); + this.metadataRef.end(); + this._root.data.Metadata = this.metadataRef; + } + } +}; +class PDFDocument extends _stream.default.Readable { + constructor() { + let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + 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) { + if (options == null) { + options = this.options; + } + if (!this.options.bufferPages) { + this.flushPages(); + } + this.page = new PDFPage(this, options); + 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) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + 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 (!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 (!Buffer.isBuffer(data)) { + data = Buffer.from(data + '\n', 'binary'); + } + 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]'; + } +} +exports.A = 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); +PDFDocument.LineWrapper = LineWrapper; + +/***/ }, + +/***/ 6092 +(module, __unused_webpack_exports, __webpack_require__) { + +var ___EXPOSE_LOADER_IMPORT___ = __webpack_require__(2736); +var ___EXPOSE_LOADER_GET_GLOBAL_THIS___ = __webpack_require__(2022); +var ___EXPOSE_LOADER_GLOBAL_THIS___ = ___EXPOSE_LOADER_GET_GLOBAL_THIS___; +if (typeof ___EXPOSE_LOADER_GLOBAL_THIS___["pdfMake"] === 'undefined') ___EXPOSE_LOADER_GLOBAL_THIS___["pdfMake"] = ___EXPOSE_LOADER_IMPORT___; +module.exports = ___EXPOSE_LOADER_IMPORT___; + + +/***/ }, + +/***/ 656 +(__unused_webpack_module, exports, __webpack_require__) { + +"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 = __webpack_require__(5181); +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)); + + +/***/ }, + +/***/ 2651 +(__unused_webpack_module, exports, __webpack_require__) { + +"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 = __webpack_require__(656); +// prettier-ignore +const utils_ts_1 = __webpack_require__(5181); +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, +}; + + +/***/ }, + +/***/ 5181 +(__unused_webpack_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); +} + + +/***/ }, + +/***/ 6784 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.SHA512_IV = exports.SHA384_IV = exports.SHA224_IV = exports.SHA256_IV = exports.HashMD = void 0; +exports.setBigUint64 = setBigUint64; +exports.Chi = Chi; +exports.Maj = Maj; +/** + * Internal Merkle-Damgard hash utils. + * @module + */ +const utils_ts_1 = __webpack_require__(3973); +/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */ +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); +} +/** Choice: a ? b : c */ +function Chi(a, b, c) { + return (a & b) ^ (~a & c); +} +/** Majority function, true if any two inputs is true. */ +function Maj(a, b, c) { + return (a & b) ^ (a & c) ^ (b & c); +} +/** + * Merkle-Damgard hash construction base class. + * Could be used to create MD5, RIPEMD, SHA1, SHA2. + */ +class HashMD extends utils_ts_1.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 = (0, utils_ts_1.createView)(this.buffer); + } + update(data) { + (0, utils_ts_1.aexists)(this); + data = (0, utils_ts_1.toBytes)(data); + (0, utils_ts_1.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); + // Fast path: we have at least one block in input, cast it to view and process + if (take === blockLen) { + const dataView = (0, utils_ts_1.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) { + (0, utils_ts_1.aexists)(this); + (0, utils_ts_1.aoutput)(out, this); + this.finished = true; + // Padding + // We can avoid allocation of buffer for padding completely if it + // was previously not allocated here. But it won't change performance. + const { buffer, view, blockLen, isLE } = this; + let { pos } = this; + // append the bit '1' to the message + buffer[pos++] = 0b10000000; + (0, utils_ts_1.clean)(this.buffer.subarray(pos)); + // we have less than padOffset left in buffer, so we cannot put length in + // current block, need process it and pad again + if (this.padOffset > blockLen - pos) { + this.process(view, 0); + pos = 0; + } + // Pad until full block byte with zeros + for (let i = pos; i < blockLen; i++) + buffer[i] = 0; + // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that + // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen. + // So we just write lowest 64 bits of that value. + setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE); + this.process(view, 0); + const oview = (0, utils_ts_1.createView)(out); + const len = this.outputLen; + // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT + 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(); + } +} +exports.HashMD = HashMD; +/** + * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53. + * Check out `test/misc/sha2-gen-iv.js` for recomputation guide. + */ +/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */ +exports.SHA256_IV = Uint32Array.from([ + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, +]); +/** Initial SHA224 state. Bits 32..64 of frac part of sqrt of primes 23..53 */ +exports.SHA224_IV = Uint32Array.from([ + 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4, +]); +/** Initial SHA384 state. Bits 0..64 of frac part of sqrt of primes 23..53 */ +exports.SHA384_IV = Uint32Array.from([ + 0xcbbb9d5d, 0xc1059ed8, 0x629a292a, 0x367cd507, 0x9159015a, 0x3070dd17, 0x152fecd8, 0xf70e5939, + 0x67332667, 0xffc00b31, 0x8eb44a87, 0x68581511, 0xdb0c2e0d, 0x64f98fa7, 0x47b5481d, 0xbefa4fa4, +]); +/** Initial SHA512 state. Bits 0..64 of frac part of sqrt of primes 2..19 */ +exports.SHA512_IV = Uint32Array.from([ + 0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1, + 0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179, +]); + + +/***/ }, + +/***/ 4996 +(__unused_webpack_module, exports) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.toBig = exports.shrSL = exports.shrSH = exports.rotrSL = exports.rotrSH = exports.rotrBL = exports.rotrBH = exports.rotr32L = exports.rotr32H = exports.rotlSL = exports.rotlSH = exports.rotlBL = exports.rotlBH = exports.add5L = exports.add5H = exports.add4L = exports.add4H = exports.add3L = exports.add3H = void 0; +exports.add = add; +exports.fromBig = fromBig; +exports.split = split; +/** + * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array. + * @todo re-check https://issues.chromium.org/issues/42212588 + * @module + */ +const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1); +const _32n = /* @__PURE__ */ 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 toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0); +exports.toBig = toBig; +// for Shift in [0, 32) +const shrSH = (h, _l, s) => h >>> s; +exports.shrSH = shrSH; +const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s); +exports.shrSL = shrSL; +// Right rotate for Shift in [1, 32) +const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s)); +exports.rotrSH = rotrSH; +const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s); +exports.rotrSL = rotrSL; +// Right rotate for Shift in (32, 64), NOTE: 32 is special case. +const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32)); +exports.rotrBH = rotrBH; +const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s)); +exports.rotrBL = rotrBL; +// Right rotate for shift===32 (just swaps l&h) +const rotr32H = (_h, l) => l; +exports.rotr32H = rotr32H; +const rotr32L = (h, _l) => h; +exports.rotr32L = rotr32L; +// Left rotate for Shift in [1, 32) +const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s)); +exports.rotlSH = rotlSH; +const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s)); +exports.rotlSL = rotlSL; +// Left rotate for Shift in (32, 64), NOTE: 32 is special case. +const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s)); +exports.rotlBH = rotlBH; +const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s)); +exports.rotlBL = rotlBL; +// JS uses 32-bit signed integers for bitwise operations which means we cannot +// simple take carry out of low bit sum by shift, we need to use division. +function add(Ah, Al, Bh, Bl) { + const l = (Al >>> 0) + (Bl >>> 0); + return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 }; +} +// Addition with more than 2 elements +const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0); +exports.add3L = add3L; +const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0; +exports.add3H = add3H; +const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0); +exports.add4L = add4L; +const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0; +exports.add4H = add4H; +const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0); +exports.add5L = add5L; +const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0; +exports.add5H = add5H; +// prettier-ignore +const u64 = { + fromBig, split, toBig, + shrSH, shrSL, + rotrSH, rotrSL, rotrBH, rotrBL, + rotr32H, rotr32L, + rotlSH, rotlSL, rotlBH, rotlBL, + add, add3L, add3H, add4L, add4H, add5H, add5L, +}; +exports["default"] = u64; + + +/***/ }, + +/***/ 2491 +(__unused_webpack_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; + + +/***/ }, + +/***/ 2650 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sha512_224 = exports.sha512_256 = exports.sha384 = exports.sha512 = exports.sha224 = exports.sha256 = exports.SHA512_256 = exports.SHA512_224 = exports.SHA384 = exports.SHA512 = exports.SHA224 = exports.SHA256 = void 0; +/** + * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256. + * SHA256 is the fastest hash implementable in JS, even faster than Blake3. + * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and + * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf). + * @module + */ +const _md_ts_1 = __webpack_require__(6784); +const u64 = __webpack_require__(4996); +const utils_ts_1 = __webpack_require__(3973); +/** + * Round constants: + * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311) + */ +// prettier-ignore +const SHA256_K = /* @__PURE__ */ 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 +]); +/** Reusable temporary buffer. "W" comes straight from spec. */ +const SHA256_W = /* @__PURE__ */ new Uint32Array(64); +class SHA256 extends _md_ts_1.HashMD { + constructor(outputLen = 32) { + super(64, outputLen, 8, false); + // We cannot use array here since array allows indexing by variable + // which means optimizer/compiler cannot use registers. + this.A = _md_ts_1.SHA256_IV[0] | 0; + this.B = _md_ts_1.SHA256_IV[1] | 0; + this.C = _md_ts_1.SHA256_IV[2] | 0; + this.D = _md_ts_1.SHA256_IV[3] | 0; + this.E = _md_ts_1.SHA256_IV[4] | 0; + this.F = _md_ts_1.SHA256_IV[5] | 0; + this.G = _md_ts_1.SHA256_IV[6] | 0; + this.H = _md_ts_1.SHA256_IV[7] | 0; + } + get() { + const { A, B, C, D, E, F, G, H } = this; + return [A, B, C, D, E, F, G, H]; + } + // prettier-ignore + 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) { + // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array + 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 = (0, utils_ts_1.rotr)(W15, 7) ^ (0, utils_ts_1.rotr)(W15, 18) ^ (W15 >>> 3); + const s1 = (0, utils_ts_1.rotr)(W2, 17) ^ (0, utils_ts_1.rotr)(W2, 19) ^ (W2 >>> 10); + SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0; + } + // Compression function main loop, 64 rounds + let { A, B, C, D, E, F, G, H } = this; + for (let i = 0; i < 64; i++) { + const sigma1 = (0, utils_ts_1.rotr)(E, 6) ^ (0, utils_ts_1.rotr)(E, 11) ^ (0, utils_ts_1.rotr)(E, 25); + const T1 = (H + sigma1 + (0, _md_ts_1.Chi)(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0; + const sigma0 = (0, utils_ts_1.rotr)(A, 2) ^ (0, utils_ts_1.rotr)(A, 13) ^ (0, utils_ts_1.rotr)(A, 22); + const T2 = (sigma0 + (0, _md_ts_1.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; + } + // Add the compressed chunk to the current hash value + 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() { + (0, utils_ts_1.clean)(SHA256_W); + } + destroy() { + this.set(0, 0, 0, 0, 0, 0, 0, 0); + (0, utils_ts_1.clean)(this.buffer); + } +} +exports.SHA256 = SHA256; +class SHA224 extends SHA256 { + constructor() { + super(28); + this.A = _md_ts_1.SHA224_IV[0] | 0; + this.B = _md_ts_1.SHA224_IV[1] | 0; + this.C = _md_ts_1.SHA224_IV[2] | 0; + this.D = _md_ts_1.SHA224_IV[3] | 0; + this.E = _md_ts_1.SHA224_IV[4] | 0; + this.F = _md_ts_1.SHA224_IV[5] | 0; + this.G = _md_ts_1.SHA224_IV[6] | 0; + this.H = _md_ts_1.SHA224_IV[7] | 0; + } +} +exports.SHA224 = SHA224; +// SHA2-512 is slower than sha256 in js because u64 operations are slow. +// Round contants +// First 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409 +// prettier-ignore +const K512 = /* @__PURE__ */ (() => u64.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 = /* @__PURE__ */ (() => K512[0])(); +const SHA512_Kl = /* @__PURE__ */ (() => K512[1])(); +// Reusable temporary buffers +const SHA512_W_H = /* @__PURE__ */ new Uint32Array(80); +const SHA512_W_L = /* @__PURE__ */ new Uint32Array(80); +class SHA512 extends _md_ts_1.HashMD { + constructor(outputLen = 64) { + super(128, outputLen, 16, false); + // We cannot use array here since array allows indexing by variable + // which means optimizer/compiler cannot use registers. + // h -- high 32 bits, l -- low 32 bits + this.Ah = _md_ts_1.SHA512_IV[0] | 0; + this.Al = _md_ts_1.SHA512_IV[1] | 0; + this.Bh = _md_ts_1.SHA512_IV[2] | 0; + this.Bl = _md_ts_1.SHA512_IV[3] | 0; + this.Ch = _md_ts_1.SHA512_IV[4] | 0; + this.Cl = _md_ts_1.SHA512_IV[5] | 0; + this.Dh = _md_ts_1.SHA512_IV[6] | 0; + this.Dl = _md_ts_1.SHA512_IV[7] | 0; + this.Eh = _md_ts_1.SHA512_IV[8] | 0; + this.El = _md_ts_1.SHA512_IV[9] | 0; + this.Fh = _md_ts_1.SHA512_IV[10] | 0; + this.Fl = _md_ts_1.SHA512_IV[11] | 0; + this.Gh = _md_ts_1.SHA512_IV[12] | 0; + this.Gl = _md_ts_1.SHA512_IV[13] | 0; + this.Hh = _md_ts_1.SHA512_IV[14] | 0; + this.Hl = _md_ts_1.SHA512_IV[15] | 0; + } + // prettier-ignore + 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]; + } + // prettier-ignore + 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) { + // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array + 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++) { + // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7) + const W15h = SHA512_W_H[i - 15] | 0; + const W15l = SHA512_W_L[i - 15] | 0; + const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7); + const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7); + // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6) + const W2h = SHA512_W_H[i - 2] | 0; + const W2l = SHA512_W_L[i - 2] | 0; + const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6); + const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6); + // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16]; + const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]); + const SUMh = u64.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; + // Compression function main loop, 80 rounds + for (let i = 0; i < 80; i++) { + // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41) + const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41); + const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41); + //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0; + const CHIh = (Eh & Fh) ^ (~Eh & Gh); + const CHIl = (El & Fl) ^ (~El & Gl); + // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i] + // prettier-ignore + const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]); + const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]); + const T1l = T1ll | 0; + // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39) + const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39); + const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.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 } = u64.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 = u64.add3L(T1l, sigma0l, MAJl); + Ah = u64.add3H(All, T1h, sigma0h, MAJh); + Al = All | 0; + } + // Add the compressed chunk to the current hash value + ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0)); + ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0)); + ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0)); + ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0)); + ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0)); + ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0)); + ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0)); + ({ h: Hh, l: Hl } = u64.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() { + (0, utils_ts_1.clean)(SHA512_W_H, SHA512_W_L); + } + destroy() { + (0, utils_ts_1.clean)(this.buffer); + this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + } +} +exports.SHA512 = SHA512; +class SHA384 extends SHA512 { + constructor() { + super(48); + this.Ah = _md_ts_1.SHA384_IV[0] | 0; + this.Al = _md_ts_1.SHA384_IV[1] | 0; + this.Bh = _md_ts_1.SHA384_IV[2] | 0; + this.Bl = _md_ts_1.SHA384_IV[3] | 0; + this.Ch = _md_ts_1.SHA384_IV[4] | 0; + this.Cl = _md_ts_1.SHA384_IV[5] | 0; + this.Dh = _md_ts_1.SHA384_IV[6] | 0; + this.Dl = _md_ts_1.SHA384_IV[7] | 0; + this.Eh = _md_ts_1.SHA384_IV[8] | 0; + this.El = _md_ts_1.SHA384_IV[9] | 0; + this.Fh = _md_ts_1.SHA384_IV[10] | 0; + this.Fl = _md_ts_1.SHA384_IV[11] | 0; + this.Gh = _md_ts_1.SHA384_IV[12] | 0; + this.Gl = _md_ts_1.SHA384_IV[13] | 0; + this.Hh = _md_ts_1.SHA384_IV[14] | 0; + this.Hl = _md_ts_1.SHA384_IV[15] | 0; + } +} +exports.SHA384 = SHA384; +/** + * Truncated SHA512/256 and SHA512/224. + * SHA512_IV is XORed with 0xa5a5a5a5a5a5a5a5, then used as "intermediary" IV of SHA512/t. + * Then t hashes string to produce result IV. + * See `test/misc/sha2-gen-iv.js`. + */ +/** SHA512/224 IV */ +const T224_IV = /* @__PURE__ */ Uint32Array.from([ + 0x8c3d37c8, 0x19544da2, 0x73e19966, 0x89dcd4d6, 0x1dfab7ae, 0x32ff9c82, 0x679dd514, 0x582f9fcf, + 0x0f6d2b69, 0x7bd44da8, 0x77e36f73, 0x04c48942, 0x3f9d85a8, 0x6a1d36c8, 0x1112e6ad, 0x91d692a1, +]); +/** SHA512/256 IV */ +const T256_IV = /* @__PURE__ */ 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; + } +} +exports.SHA512_224 = SHA512_224; +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; + } +} +exports.SHA512_256 = SHA512_256; +/** + * SHA2-256 hash function from RFC 4634. + * + * It is the fastest JS hash, even faster than Blake3. + * To break sha256 using birthday attack, attackers need to try 2^128 hashes. + * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025. + */ +exports.sha256 = (0, utils_ts_1.createHasher)(() => new SHA256()); +/** SHA2-224 hash function from RFC 4634 */ +exports.sha224 = (0, utils_ts_1.createHasher)(() => new SHA224()); +/** SHA2-512 hash function from RFC 4634. */ +exports.sha512 = (0, utils_ts_1.createHasher)(() => new SHA512()); +/** SHA2-384 hash function from RFC 4634. */ +exports.sha384 = (0, utils_ts_1.createHasher)(() => new SHA384()); +/** + * SHA2-512/256 "truncated" hash function, with improved resistance to length extension attacks. + * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf). + */ +exports.sha512_256 = (0, utils_ts_1.createHasher)(() => new SHA512_256()); +/** + * SHA2-512/224 "truncated" hash function, with improved resistance to length extension attacks. + * See the paper on [truncated SHA512](https://eprint.iacr.org/2010/548.pdf). + */ +exports.sha512_224 = (0, utils_ts_1.createHasher)(() => new SHA512_224()); + + +/***/ }, + +/***/ 7785 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.sha224 = exports.SHA224 = exports.sha256 = exports.SHA256 = void 0; +/** + * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3. + * + * To break sha256 using birthday attack, attackers need to try 2^128 hashes. + * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025. + * + * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf). + * @module + * @deprecated + */ +const sha2_ts_1 = __webpack_require__(2650); +/** @deprecated Use import from `noble/hashes/sha2` module */ +exports.SHA256 = sha2_ts_1.SHA256; +/** @deprecated Use import from `noble/hashes/sha2` module */ +exports.sha256 = sha2_ts_1.sha256; +/** @deprecated Use import from `noble/hashes/sha2` module */ +exports.SHA224 = sha2_ts_1.SHA224; +/** @deprecated Use import from `noble/hashes/sha2` module */ +exports.sha224 = sha2_ts_1.sha224; + + +/***/ }, + +/***/ 3973 +(__unused_webpack_module, exports, __webpack_require__) { + +"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 = __webpack_require__(2491); +/** 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'); +} + + +/***/ }, + +/***/ 7801 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); +// Currently in sync with Node.js lib/assert.js +// https://github.com/nodejs/node/commit/2a51ae424a513ec9a6aa3466baa0cc1d55dd4f3b + +// Originally from narwhal.js (http://narwhaljs.org) +// Copyright (c) 2009 Thomas Robinson <280north.com> +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the 'Software'), to +// deal in the Software without restriction, including without limitation the +// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +// sell copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +var _require = __webpack_require__(5403), + _require$codes = _require.codes, + ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT, + ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, + ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE, + ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE, + ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS; +var AssertionError = __webpack_require__(5416); +var _require2 = __webpack_require__(7187), + inspect = _require2.inspect; +var _require$types = (__webpack_require__(7187).types), + isPromise = _require$types.isPromise, + isRegExp = _require$types.isRegExp; +var objectAssign = __webpack_require__(7596)(); +var objectIs = __webpack_require__(9636)(); +var RegExpPrototypeTest = __webpack_require__(7913)('RegExp.prototype.test'); +var errorCache = new Map(); +var isDeepEqual; +var isDeepStrictEqual; +var parseExpressionAt; +var findNodeAround; +var decoder; +function lazyLoadComparison() { + var comparison = __webpack_require__(6781); + isDeepEqual = comparison.isDeepEqual; + isDeepStrictEqual = comparison.isDeepStrictEqual; +} + +// Escape control characters but not \n and \t to keep the line breaks and +// indentation intact. +// eslint-disable-next-line no-control-regex +var escapeSequencesRegExp = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g; +var meta = (/* unused pure expression or super */ null && (["\\u0000", "\\u0001", "\\u0002", "\\u0003", "\\u0004", "\\u0005", "\\u0006", "\\u0007", '\\b', '', '', "\\u000b", '\\f', '', "\\u000e", "\\u000f", "\\u0010", "\\u0011", "\\u0012", "\\u0013", "\\u0014", "\\u0015", "\\u0016", "\\u0017", "\\u0018", "\\u0019", "\\u001a", "\\u001b", "\\u001c", "\\u001d", "\\u001e", "\\u001f"])); +var escapeFn = function escapeFn(str) { + return meta[str.charCodeAt(0)]; +}; +var warned = false; + +// The assert module provides functions that throw +// AssertionError's when particular conditions are not met. The +// assert module must conform to the following interface. + +var assert = module.exports = ok; +var NO_EXCEPTION_SENTINEL = {}; + +// All of the following functions must throw an AssertionError +// when a corresponding condition is not met, with a message that +// may be undefined if not provided. All assertion methods provide +// both the actual and expected values to the assertion error for +// display purposes. + +function innerFail(obj) { + if (obj.message instanceof Error) throw obj.message; + throw new AssertionError(obj); +} +function fail(actual, expected, message, operator, stackStartFn) { + var argsLen = arguments.length; + var internalMessage; + if (argsLen === 0) { + internalMessage = 'Failed'; + } else if (argsLen === 1) { + message = actual; + actual = undefined; + } else { + if (warned === false) { + warned = true; + var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console); + warn('assert.fail() with more than one argument is deprecated. ' + 'Please use assert.strictEqual() instead or only pass a message.', 'DeprecationWarning', 'DEP0094'); + } + if (argsLen === 2) operator = '!='; + } + if (message instanceof Error) throw message; + var errArgs = { + actual: actual, + expected: expected, + operator: operator === undefined ? 'fail' : operator, + stackStartFn: stackStartFn || fail + }; + if (message !== undefined) { + errArgs.message = message; + } + var err = new AssertionError(errArgs); + if (internalMessage) { + err.message = internalMessage; + err.generatedMessage = true; + } + throw err; +} +assert.fail = fail; + +// The AssertionError is defined in internal/error. +assert.AssertionError = AssertionError; +function innerOk(fn, argLen, value, message) { + if (!value) { + var generatedMessage = false; + if (argLen === 0) { + generatedMessage = true; + message = 'No value argument passed to `assert.ok()`'; + } else if (message instanceof Error) { + throw message; + } + var err = new AssertionError({ + actual: value, + expected: true, + message: message, + operator: '==', + stackStartFn: fn + }); + err.generatedMessage = generatedMessage; + throw err; + } +} + +// Pure assertion tests whether a value is truthy, as determined +// by !!value. +function ok() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + innerOk.apply(void 0, [ok, args.length].concat(args)); +} +assert.ok = ok; + +// The equality assertion tests shallow, coercive equality with ==. +/* eslint-disable no-restricted-properties */ +assert.equal = function equal(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + // eslint-disable-next-line eqeqeq + if (actual != expected) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: '==', + stackStartFn: equal + }); + } +}; + +// The non-equality assertion tests for whether two objects are not +// equal with !=. +assert.notEqual = function notEqual(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + // eslint-disable-next-line eqeqeq + if (actual == expected) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: '!=', + stackStartFn: notEqual + }); + } +}; + +// The equivalence assertion tests a deep equality relation. +assert.deepEqual = function deepEqual(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + if (isDeepEqual === undefined) lazyLoadComparison(); + if (!isDeepEqual(actual, expected)) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: 'deepEqual', + stackStartFn: deepEqual + }); + } +}; + +// The non-equivalence assertion tests for any deep inequality. +assert.notDeepEqual = function notDeepEqual(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + if (isDeepEqual === undefined) lazyLoadComparison(); + if (isDeepEqual(actual, expected)) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: 'notDeepEqual', + stackStartFn: notDeepEqual + }); + } +}; +/* eslint-enable */ + +assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + if (isDeepEqual === undefined) lazyLoadComparison(); + if (!isDeepStrictEqual(actual, expected)) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: 'deepStrictEqual', + stackStartFn: deepStrictEqual + }); + } +}; +assert.notDeepStrictEqual = notDeepStrictEqual; +function notDeepStrictEqual(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + if (isDeepEqual === undefined) lazyLoadComparison(); + if (isDeepStrictEqual(actual, expected)) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: 'notDeepStrictEqual', + stackStartFn: notDeepStrictEqual + }); + } +} +assert.strictEqual = function strictEqual(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + if (!objectIs(actual, expected)) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: 'strictEqual', + stackStartFn: strictEqual + }); + } +}; +assert.notStrictEqual = function notStrictEqual(actual, expected, message) { + if (arguments.length < 2) { + throw new ERR_MISSING_ARGS('actual', 'expected'); + } + if (objectIs(actual, expected)) { + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: 'notStrictEqual', + stackStartFn: notStrictEqual + }); + } +}; +var Comparison = /*#__PURE__*/_createClass(function Comparison(obj, keys, actual) { + var _this = this; + _classCallCheck(this, Comparison); + keys.forEach(function (key) { + if (key in obj) { + if (actual !== undefined && typeof actual[key] === 'string' && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key])) { + _this[key] = actual[key]; + } else { + _this[key] = obj[key]; + } + } + }); +}); +function compareExceptionKey(actual, expected, key, message, keys, fn) { + if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) { + if (!message) { + // Create placeholder objects to create a nice output. + var a = new Comparison(actual, keys); + var b = new Comparison(expected, keys, actual); + var err = new AssertionError({ + actual: a, + expected: b, + operator: 'deepStrictEqual', + stackStartFn: fn + }); + err.actual = actual; + err.expected = expected; + err.operator = fn.name; + throw err; + } + innerFail({ + actual: actual, + expected: expected, + message: message, + operator: fn.name, + stackStartFn: fn + }); + } +} +function expectedException(actual, expected, msg, fn) { + if (typeof expected !== 'function') { + if (isRegExp(expected)) return RegExpPrototypeTest(expected, actual); + // assert.doesNotThrow does not accept objects. + if (arguments.length === 2) { + throw new ERR_INVALID_ARG_TYPE('expected', ['Function', 'RegExp'], expected); + } + + // Handle primitives properly. + if (_typeof(actual) !== 'object' || actual === null) { + var err = new AssertionError({ + actual: actual, + expected: expected, + message: msg, + operator: 'deepStrictEqual', + stackStartFn: fn + }); + err.operator = fn.name; + throw err; + } + var keys = Object.keys(expected); + // Special handle errors to make sure the name and the message are compared + // as well. + if (expected instanceof Error) { + keys.push('name', 'message'); + } else if (keys.length === 0) { + throw new ERR_INVALID_ARG_VALUE('error', expected, 'may not be an empty object'); + } + if (isDeepEqual === undefined) lazyLoadComparison(); + keys.forEach(function (key) { + if (typeof actual[key] === 'string' && isRegExp(expected[key]) && RegExpPrototypeTest(expected[key], actual[key])) { + return; + } + compareExceptionKey(actual, expected, key, msg, keys, fn); + }); + return true; + } + // Guard instanceof against arrow functions as they don't have a prototype. + if (expected.prototype !== undefined && actual instanceof expected) { + return true; + } + if (Error.isPrototypeOf(expected)) { + return false; + } + return expected.call({}, actual) === true; +} +function getActual(fn) { + if (typeof fn !== 'function') { + throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn); + } + try { + fn(); + } catch (e) { + return e; + } + return NO_EXCEPTION_SENTINEL; +} +function checkIsPromise(obj) { + // Accept native ES6 promises and promises that are implemented in a similar + // way. Do not accept thenables that use a function as `obj` and that have no + // `catch` handler. + + // TODO: thenables are checked up until they have the correct methods, + // but according to documentation, the `then` method should receive + // the `fulfill` and `reject` arguments as well or it may be never resolved. + + return isPromise(obj) || obj !== null && _typeof(obj) === 'object' && typeof obj.then === 'function' && typeof obj.catch === 'function'; +} +function waitForActual(promiseFn) { + return Promise.resolve().then(function () { + var resultPromise; + if (typeof promiseFn === 'function') { + // Return a rejected promise if `promiseFn` throws synchronously. + resultPromise = promiseFn(); + // Fail in case no promise is returned. + if (!checkIsPromise(resultPromise)) { + throw new ERR_INVALID_RETURN_VALUE('instance of Promise', 'promiseFn', resultPromise); + } + } else if (checkIsPromise(promiseFn)) { + resultPromise = promiseFn; + } else { + throw new ERR_INVALID_ARG_TYPE('promiseFn', ['Function', 'Promise'], promiseFn); + } + return Promise.resolve().then(function () { + return resultPromise; + }).then(function () { + return NO_EXCEPTION_SENTINEL; + }).catch(function (e) { + return e; + }); + }); +} +function expectsError(stackStartFn, actual, error, message) { + if (typeof error === 'string') { + if (arguments.length === 4) { + throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error); + } + if (_typeof(actual) === 'object' && actual !== null) { + if (actual.message === error) { + throw new ERR_AMBIGUOUS_ARGUMENT('error/message', "The error message \"".concat(actual.message, "\" is identical to the message.")); + } + } else if (actual === error) { + throw new ERR_AMBIGUOUS_ARGUMENT('error/message', "The error \"".concat(actual, "\" is identical to the message.")); + } + message = error; + error = undefined; + } else if (error != null && _typeof(error) !== 'object' && typeof error !== 'function') { + throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error); + } + if (actual === NO_EXCEPTION_SENTINEL) { + var details = ''; + if (error && error.name) { + details += " (".concat(error.name, ")"); + } + details += message ? ": ".concat(message) : '.'; + var fnType = stackStartFn.name === 'rejects' ? 'rejection' : 'exception'; + innerFail({ + actual: undefined, + expected: error, + operator: stackStartFn.name, + message: "Missing expected ".concat(fnType).concat(details), + stackStartFn: stackStartFn + }); + } + if (error && !expectedException(actual, error, message, stackStartFn)) { + throw actual; + } +} +function expectsNoError(stackStartFn, actual, error, message) { + if (actual === NO_EXCEPTION_SENTINEL) return; + if (typeof error === 'string') { + message = error; + error = undefined; + } + if (!error || expectedException(actual, error)) { + var details = message ? ": ".concat(message) : '.'; + var fnType = stackStartFn.name === 'doesNotReject' ? 'rejection' : 'exception'; + innerFail({ + actual: actual, + expected: error, + operator: stackStartFn.name, + message: "Got unwanted ".concat(fnType).concat(details, "\n") + "Actual message: \"".concat(actual && actual.message, "\""), + stackStartFn: stackStartFn + }); + } + throw actual; +} +assert.throws = function throws(promiseFn) { + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args)); +}; +assert.rejects = function rejects(promiseFn) { + for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) { + args[_key3 - 1] = arguments[_key3]; + } + return waitForActual(promiseFn).then(function (result) { + return expectsError.apply(void 0, [rejects, result].concat(args)); + }); +}; +assert.doesNotThrow = function doesNotThrow(fn) { + for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { + args[_key4 - 1] = arguments[_key4]; + } + expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args)); +}; +assert.doesNotReject = function doesNotReject(fn) { + for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) { + args[_key5 - 1] = arguments[_key5]; + } + return waitForActual(fn).then(function (result) { + return expectsNoError.apply(void 0, [doesNotReject, result].concat(args)); + }); +}; +assert.ifError = function ifError(err) { + if (err !== null && err !== undefined) { + var message = 'ifError got unwanted exception: '; + if (_typeof(err) === 'object' && typeof err.message === 'string') { + if (err.message.length === 0 && err.constructor) { + message += err.constructor.name; + } else { + message += err.message; + } + } else { + message += inspect(err); + } + var newErr = new AssertionError({ + actual: err, + expected: null, + operator: 'ifError', + message: message, + stackStartFn: ifError + }); + + // Make sure we actually have a stack trace! + var origStack = err.stack; + if (typeof origStack === 'string') { + // This will remove any duplicated frames from the error frames taken + // from within `ifError` and add the original error frames to the newly + // created ones. + var tmp2 = origStack.split('\n'); + tmp2.shift(); + // Filter all frames existing in err.stack. + var tmp1 = newErr.stack.split('\n'); + for (var i = 0; i < tmp2.length; i++) { + // Find the first occurrence of the frame. + var pos = tmp1.indexOf(tmp2[i]); + if (pos !== -1) { + // Only keep new frames. + tmp1 = tmp1.slice(0, pos); + break; + } + } + newErr.stack = "".concat(tmp1.join('\n'), "\n").concat(tmp2.join('\n')); + } + throw newErr; + } +}; + +// Currently in sync with Node.js lib/assert.js +// https://github.com/nodejs/node/commit/2a871df3dfb8ea663ef5e1f8f62701ec51384ecb +function internalMatch(string, regexp, message, fn, fnName) { + if (!isRegExp(regexp)) { + throw new ERR_INVALID_ARG_TYPE('regexp', 'RegExp', regexp); + } + var match = fnName === 'match'; + if (typeof string !== 'string' || RegExpPrototypeTest(regexp, string) !== match) { + if (message instanceof Error) { + throw message; + } + var generatedMessage = !message; + + // 'The input was expected to not match the regular expression ' + + message = message || (typeof string !== 'string' ? 'The "string" argument must be of type string. Received type ' + "".concat(_typeof(string), " (").concat(inspect(string), ")") : (match ? 'The input did not match the regular expression ' : 'The input was expected to not match the regular expression ') + "".concat(inspect(regexp), ". Input:\n\n").concat(inspect(string), "\n")); + var err = new AssertionError({ + actual: string, + expected: regexp, + message: message, + operator: fnName, + stackStartFn: fn + }); + err.generatedMessage = generatedMessage; + throw err; + } +} +assert.match = function match(string, regexp, message) { + internalMatch(string, regexp, message, match, 'match'); +}; +assert.doesNotMatch = function doesNotMatch(string, regexp, message) { + internalMatch(string, regexp, message, doesNotMatch, 'doesNotMatch'); +}; + +// Expose a strict only variant of assert +function strict() { + for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { + args[_key6] = arguments[_key6]; + } + innerOk.apply(void 0, [strict, args.length].concat(args)); +} +assert.strict = objectAssign(strict, assert, { + equal: assert.strictEqual, + deepEqual: assert.deepStrictEqual, + notEqual: assert.notStrictEqual, + notDeepEqual: assert.notDeepStrictEqual +}); +assert.strict.strict = assert.strict; + +/***/ }, + +/***/ 5416 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); +// Currently in sync with Node.js lib/internal/assert/assertion_error.js +// https://github.com/nodejs/node/commit/0817840f775032169ddd70c85ac059f18ffcc81c + + + +function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; } +function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); } +function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +var _require = __webpack_require__(7187), + inspect = _require.inspect; +var _require2 = __webpack_require__(5403), + ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE; + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith +function endsWith(str, search, this_len) { + if (this_len === undefined || this_len > str.length) { + this_len = str.length; + } + return str.substring(this_len - search.length, this_len) === search; +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat +function repeat(str, count) { + count = Math.floor(count); + if (str.length == 0 || count == 0) return ''; + var maxCount = str.length * count; + count = Math.floor(Math.log(count) / Math.log(2)); + while (count) { + str += str; + count--; + } + str += str.substring(0, maxCount - str.length); + return str; +} +var blue = ''; +var green = ''; +var red = ''; +var white = ''; +var kReadableOperator = { + deepStrictEqual: 'Expected values to be strictly deep-equal:', + strictEqual: 'Expected values to be strictly equal:', + strictEqualObject: 'Expected "actual" to be reference-equal to "expected":', + deepEqual: 'Expected values to be loosely deep-equal:', + equal: 'Expected values to be loosely equal:', + notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:', + notStrictEqual: 'Expected "actual" to be strictly unequal to:', + notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":', + notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:', + notEqual: 'Expected "actual" to be loosely unequal to:', + notIdentical: 'Values identical but not reference-equal:' +}; + +// Comparing short primitives should just show === / !== instead of using the +// diff. +var kMaxShortLength = 10; +function copyError(source) { + var keys = Object.keys(source); + var target = Object.create(Object.getPrototypeOf(source)); + keys.forEach(function (key) { + target[key] = source[key]; + }); + Object.defineProperty(target, 'message', { + value: source.message + }); + return target; +} +function inspectValue(val) { + // The util.inspect default values could be changed. This makes sure the + // error messages contain the necessary information nevertheless. + return inspect(val, { + compact: false, + customInspect: false, + depth: 1000, + maxArrayLength: Infinity, + // Assert compares only enumerable properties (with a few exceptions). + showHidden: false, + // Having a long line as error is better than wrapping the line for + // comparison for now. + // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we + // have meta information about the inspected properties (i.e., know where + // in what line the property starts and ends). + breakLength: Infinity, + // Assert does not detect proxies currently. + showProxy: false, + sorted: true, + // Inspect getters as we also check them when comparing entries. + getters: true + }); +} +function createErrDiff(actual, expected, operator) { + var other = ''; + var res = ''; + var lastPos = 0; + var end = ''; + var skipped = false; + var actualInspected = inspectValue(actual); + var actualLines = actualInspected.split('\n'); + var expectedLines = inspectValue(expected).split('\n'); + var i = 0; + var indicator = ''; + + // In case both values are objects explicitly mark them as not reference equal + // for the `strictEqual` operator. + if (operator === 'strictEqual' && _typeof(actual) === 'object' && _typeof(expected) === 'object' && actual !== null && expected !== null) { + operator = 'strictEqualObject'; + } + + // If "actual" and "expected" fit on a single line and they are not strictly + // equal, check further special handling. + if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) { + var inputLength = actualLines[0].length + expectedLines[0].length; + // If the character length of "actual" and "expected" together is less than + // kMaxShortLength and if neither is an object and at least one of them is + // not `zero`, use the strict equal comparison to visualize the output. + if (inputLength <= kMaxShortLength) { + if ((_typeof(actual) !== 'object' || actual === null) && (_typeof(expected) !== 'object' || expected === null) && (actual !== 0 || expected !== 0)) { + // -0 === +0 + return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n"); + } + } else if (operator !== 'strictEqualObject') { + // If the stderr is a tty and the input length is lower than the current + // columns per line, add a mismatch indicator below the output. If it is + // not a tty, use a default value of 80 characters. + var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80; + if (inputLength < maxLength) { + while (actualLines[0][i] === expectedLines[0][i]) { + i++; + } + // Ignore the first characters. + if (i > 2) { + // Add position indicator for the first mismatch in case it is a + // single line and the input length is less than the column length. + indicator = "\n ".concat(repeat(' ', i), "^"); + i = 0; + } + } + } + } + + // Remove all ending lines that match (this optimizes the output for + // readability by reducing the number of total changed lines). + var a = actualLines[actualLines.length - 1]; + var b = expectedLines[expectedLines.length - 1]; + while (a === b) { + if (i++ < 2) { + end = "\n ".concat(a).concat(end); + } else { + other = a; + } + actualLines.pop(); + expectedLines.pop(); + if (actualLines.length === 0 || expectedLines.length === 0) break; + a = actualLines[actualLines.length - 1]; + b = expectedLines[expectedLines.length - 1]; + } + var maxLines = Math.max(actualLines.length, expectedLines.length); + // Strict equal with identical objects that are not identical by reference. + // E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() }) + if (maxLines === 0) { + // We have to get the result again. The lines were all removed before. + var _actualLines = actualInspected.split('\n'); + + // Only remove lines in case it makes sense to collapse those. + // TODO: Accept env to always show the full error. + if (_actualLines.length > 30) { + _actualLines[26] = "".concat(blue, "...").concat(white); + while (_actualLines.length > 27) { + _actualLines.pop(); + } + } + return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join('\n'), "\n"); + } + if (i > 3) { + end = "\n".concat(blue, "...").concat(white).concat(end); + skipped = true; + } + if (other !== '') { + end = "\n ".concat(other).concat(end); + other = ''; + } + var printedLines = 0; + var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white); + var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped"); + for (i = 0; i < maxLines; i++) { + // Only extra expected lines exist + var cur = i - lastPos; + if (actualLines.length < i + 1) { + // If the last diverging line is more than one line above and the + // current line is at least line three, add some of the former lines and + // also add dots to indicate skipped entries. + if (cur > 1 && i > 2) { + if (cur > 4) { + res += "\n".concat(blue, "...").concat(white); + skipped = true; + } else if (cur > 3) { + res += "\n ".concat(expectedLines[i - 2]); + printedLines++; + } + res += "\n ".concat(expectedLines[i - 1]); + printedLines++; + } + // Mark the current line as the last diverging one. + lastPos = i; + // Add the expected line to the cache. + other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i]); + printedLines++; + // Only extra actual lines exist + } else if (expectedLines.length < i + 1) { + // If the last diverging line is more than one line above and the + // current line is at least line three, add some of the former lines and + // also add dots to indicate skipped entries. + if (cur > 1 && i > 2) { + if (cur > 4) { + res += "\n".concat(blue, "...").concat(white); + skipped = true; + } else if (cur > 3) { + res += "\n ".concat(actualLines[i - 2]); + printedLines++; + } + res += "\n ".concat(actualLines[i - 1]); + printedLines++; + } + // Mark the current line as the last diverging one. + lastPos = i; + // Add the actual line to the result. + res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i]); + printedLines++; + // Lines diverge + } else { + var expectedLine = expectedLines[i]; + var actualLine = actualLines[i]; + // If the lines diverge, specifically check for lines that only diverge by + // a trailing comma. In that case it is actually identical and we should + // mark it as such. + var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ',') || actualLine.slice(0, -1) !== expectedLine); + // If the expected line has a trailing comma but is otherwise identical, + // add a comma at the end of the actual line. Otherwise the output could + // look weird as in: + // + // [ + // 1 // No comma at the end! + // + 2 + // ] + // + if (divergingLines && endsWith(expectedLine, ',') && expectedLine.slice(0, -1) === actualLine) { + divergingLines = false; + actualLine += ','; + } + if (divergingLines) { + // If the last diverging line is more than one line above and the + // current line is at least line three, add some of the former lines and + // also add dots to indicate skipped entries. + if (cur > 1 && i > 2) { + if (cur > 4) { + res += "\n".concat(blue, "...").concat(white); + skipped = true; + } else if (cur > 3) { + res += "\n ".concat(actualLines[i - 2]); + printedLines++; + } + res += "\n ".concat(actualLines[i - 1]); + printedLines++; + } + // Mark the current line as the last diverging one. + lastPos = i; + // Add the actual line to the result and cache the expected diverging + // line so consecutive diverging lines show up as +++--- and not +-+-+-. + res += "\n".concat(green, "+").concat(white, " ").concat(actualLine); + other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine); + printedLines += 2; + // Lines are identical + } else { + // Add all cached information to the result before adding other things + // and reset the cache. + res += other; + other = ''; + // If the last diverging line is exactly one line above or if it is the + // very first line, add the line to the result. + if (cur === 1 || i === 0) { + res += "\n ".concat(actualLine); + printedLines++; + } + } + } + // Inspected object to big (Show ~20 rows max) + if (printedLines > 20 && i < maxLines - 2) { + return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white); + } + } + return "".concat(msg).concat(skipped ? skippedMsg : '', "\n").concat(res).concat(other).concat(end).concat(indicator); +} +var AssertionError = /*#__PURE__*/function (_Error, _inspect$custom) { + _inherits(AssertionError, _Error); + var _super = _createSuper(AssertionError); + function AssertionError(options) { + var _this; + _classCallCheck(this, AssertionError); + if (_typeof(options) !== 'object' || options === null) { + throw new ERR_INVALID_ARG_TYPE('options', 'Object', options); + } + var message = options.message, + operator = options.operator, + stackStartFn = options.stackStartFn; + var actual = options.actual, + expected = options.expected; + var limit = Error.stackTraceLimit; + Error.stackTraceLimit = 0; + if (message != null) { + _this = _super.call(this, String(message)); + } else { + if (process.stderr && process.stderr.isTTY) { + // Reset on each call to make sure we handle dynamically set environment + // variables correct. + if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) { + blue = "\x1B[34m"; + green = "\x1B[32m"; + white = "\x1B[39m"; + red = "\x1B[31m"; + } else { + blue = ''; + green = ''; + white = ''; + red = ''; + } + } + // Prevent the error stack from being visible by duplicating the error + // in a very close way to the original in case both sides are actually + // instances of Error. + if (_typeof(actual) === 'object' && actual !== null && _typeof(expected) === 'object' && expected !== null && 'stack' in actual && actual instanceof Error && 'stack' in expected && expected instanceof Error) { + actual = copyError(actual); + expected = copyError(expected); + } + if (operator === 'deepStrictEqual' || operator === 'strictEqual') { + _this = _super.call(this, createErrDiff(actual, expected, operator)); + } else if (operator === 'notDeepStrictEqual' || operator === 'notStrictEqual') { + // In case the objects are equal but the operator requires unequal, show + // the first object and say A equals B + var base = kReadableOperator[operator]; + var res = inspectValue(actual).split('\n'); + + // In case "actual" is an object, it should not be reference equal. + if (operator === 'notStrictEqual' && _typeof(actual) === 'object' && actual !== null) { + base = kReadableOperator.notStrictEqualObject; + } + + // Only remove lines in case it makes sense to collapse those. + // TODO: Accept env to always show the full error. + if (res.length > 30) { + res[26] = "".concat(blue, "...").concat(white); + while (res.length > 27) { + res.pop(); + } + } + + // Only print a single input. + if (res.length === 1) { + _this = _super.call(this, "".concat(base, " ").concat(res[0])); + } else { + _this = _super.call(this, "".concat(base, "\n\n").concat(res.join('\n'), "\n")); + } + } else { + var _res = inspectValue(actual); + var other = ''; + var knownOperators = kReadableOperator[operator]; + if (operator === 'notDeepEqual' || operator === 'notEqual') { + _res = "".concat(kReadableOperator[operator], "\n\n").concat(_res); + if (_res.length > 1024) { + _res = "".concat(_res.slice(0, 1021), "..."); + } + } else { + other = "".concat(inspectValue(expected)); + if (_res.length > 512) { + _res = "".concat(_res.slice(0, 509), "..."); + } + if (other.length > 512) { + other = "".concat(other.slice(0, 509), "..."); + } + if (operator === 'deepEqual' || operator === 'equal') { + _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n"); + } else { + other = " ".concat(operator, " ").concat(other); + } + } + _this = _super.call(this, "".concat(_res).concat(other)); + } + } + Error.stackTraceLimit = limit; + _this.generatedMessage = !message; + Object.defineProperty(_assertThisInitialized(_this), 'name', { + value: 'AssertionError [ERR_ASSERTION]', + enumerable: false, + writable: true, + configurable: true + }); + _this.code = 'ERR_ASSERTION'; + _this.actual = actual; + _this.expected = expected; + _this.operator = operator; + if (Error.captureStackTrace) { + // eslint-disable-next-line no-restricted-syntax + Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn); + } + // Create error message including the error code in the name. + _this.stack; + // Reset the name. + _this.name = 'AssertionError'; + return _possibleConstructorReturn(_this); + } + _createClass(AssertionError, [{ + key: "toString", + value: function toString() { + return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message); + } + }, { + key: _inspect$custom, + value: function value(recurseTimes, ctx) { + // This limits the `actual` and `expected` property default inspection to + // the minimum depth. Otherwise those values would be too verbose compared + // to the actual error message which contains a combined view of these two + // input values. + return inspect(this, _objectSpread(_objectSpread({}, ctx), {}, { + customInspect: false, + depth: 0 + })); + } + }]); + return AssertionError; +}( /*#__PURE__*/_wrapNativeSuper(Error), inspect.custom); +module.exports = AssertionError; + +/***/ }, + +/***/ 5403 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +// Currently in sync with Node.js lib/internal/errors.js +// https://github.com/nodejs/node/commit/3b044962c48fe313905877a96b5d0894a5404f6f + +/* eslint node-core/documented-errors: "error" */ +/* eslint node-core/alphabetize-errors: "error" */ +/* eslint node-core/prefer-util-format-errors: "error" */ + + + +// The whole point behind this internal module is to allow Node.js to no +// longer be forced to treat every error message change as a semver-major +// change. The NodeError classes here all expose a `code` property whose +// value statically and permanently identifies the error. While the error +// message may change, the code should not. +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); } +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } +function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; } +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); } +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } +function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } +function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); } +var codes = {}; + +// Lazy loaded +var assert; +var util; +function createErrorType(code, message, Base) { + if (!Base) { + Base = Error; + } + function getMessage(arg1, arg2, arg3) { + if (typeof message === 'string') { + return message; + } else { + return message(arg1, arg2, arg3); + } + } + var NodeError = /*#__PURE__*/function (_Base) { + _inherits(NodeError, _Base); + var _super = _createSuper(NodeError); + function NodeError(arg1, arg2, arg3) { + var _this; + _classCallCheck(this, NodeError); + _this = _super.call(this, getMessage(arg1, arg2, arg3)); + _this.code = code; + return _this; + } + return _createClass(NodeError); + }(Base); + codes[code] = NodeError; +} + +// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js +function oneOf(expected, thing) { + if (Array.isArray(expected)) { + var len = expected.length; + expected = expected.map(function (i) { + return String(i); + }); + if (len > 2) { + return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1]; + } else if (len === 2) { + return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]); + } else { + return "of ".concat(thing, " ").concat(expected[0]); + } + } else { + return "of ".concat(thing, " ").concat(String(expected)); + } +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith +function startsWith(str, search, pos) { + return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search; +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith +function endsWith(str, search, this_len) { + if (this_len === undefined || this_len > str.length) { + this_len = str.length; + } + return str.substring(this_len - search.length, this_len) === search; +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes +function includes(str, search, start) { + if (typeof start !== 'number') { + start = 0; + } + if (start + search.length > str.length) { + return false; + } else { + return str.indexOf(search, start) !== -1; + } +} +createErrorType('ERR_AMBIGUOUS_ARGUMENT', 'The "%s" argument is ambiguous. %s', TypeError); +createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) { + if (assert === undefined) assert = __webpack_require__(7801); + assert(typeof name === 'string', "'name' must be a string"); + + // determiner: 'must be' or 'must not be' + var determiner; + if (typeof expected === 'string' && startsWith(expected, 'not ')) { + determiner = 'must not be'; + expected = expected.replace(/^not /, ''); + } else { + determiner = 'must be'; + } + var msg; + if (endsWith(name, ' argument')) { + // For cases like 'first argument' + msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); + } else { + var type = includes(name, '.') ? 'property' : 'argument'; + msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); + } + + // TODO(BridgeAR): Improve the output by showing `null` and similar. + msg += ". Received type ".concat(_typeof(actual)); + return msg; +}, TypeError); +createErrorType('ERR_INVALID_ARG_VALUE', function (name, value) { + var reason = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'is invalid'; + if (util === undefined) util = __webpack_require__(7187); + var inspected = util.inspect(value); + if (inspected.length > 128) { + inspected = "".concat(inspected.slice(0, 128), "..."); + } + return "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected); +}, TypeError, RangeError); +createErrorType('ERR_INVALID_RETURN_VALUE', function (input, name, value) { + var type; + if (value && value.constructor && value.constructor.name) { + type = "instance of ".concat(value.constructor.name); + } else { + type = "type ".concat(_typeof(value)); + } + return "Expected ".concat(input, " to be returned from the \"").concat(name, "\"") + " function but got ".concat(type, "."); +}, TypeError); +createErrorType('ERR_MISSING_ARGS', function () { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + if (assert === undefined) assert = __webpack_require__(7801); + assert(args.length > 0, 'At least one arg needs to be specified'); + var msg = 'The '; + var len = args.length; + args = args.map(function (a) { + return "\"".concat(a, "\""); + }); + switch (len) { + case 1: + msg += "".concat(args[0], " argument"); + break; + case 2: + msg += "".concat(args[0], " and ").concat(args[1], " arguments"); + break; + default: + msg += args.slice(0, len - 1).join(', '); + msg += ", and ".concat(args[len - 1], " arguments"); + break; + } + return "".concat(msg, " must be specified"); +}, TypeError); +module.exports.codes = codes; + +/***/ }, + +/***/ 6781 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +// Currently in sync with Node.js lib/internal/util/comparisons.js +// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9 + + + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); } +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } +function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } +function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } +function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } } +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } +function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } +var regexFlagsSupported = /a/g.flags !== undefined; +var arrayFromSet = function arrayFromSet(set) { + var array = []; + set.forEach(function (value) { + return array.push(value); + }); + return array; +}; +var arrayFromMap = function arrayFromMap(map) { + var array = []; + map.forEach(function (value, key) { + return array.push([key, value]); + }); + return array; +}; +var objectIs = Object.is ? Object.is : __webpack_require__(8527); +var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function () { + return []; +}; +var numberIsNaN = Number.isNaN ? Number.isNaN : __webpack_require__(7051); +function uncurryThis(f) { + return f.call.bind(f); +} +var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty); +var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable); +var objectToString = uncurryThis(Object.prototype.toString); +var _require$types = (__webpack_require__(7187).types), + isAnyArrayBuffer = _require$types.isAnyArrayBuffer, + isArrayBufferView = _require$types.isArrayBufferView, + isDate = _require$types.isDate, + isMap = _require$types.isMap, + isRegExp = _require$types.isRegExp, + isSet = _require$types.isSet, + isNativeError = _require$types.isNativeError, + isBoxedPrimitive = _require$types.isBoxedPrimitive, + isNumberObject = _require$types.isNumberObject, + isStringObject = _require$types.isStringObject, + isBooleanObject = _require$types.isBooleanObject, + isBigIntObject = _require$types.isBigIntObject, + isSymbolObject = _require$types.isSymbolObject, + isFloat32Array = _require$types.isFloat32Array, + isFloat64Array = _require$types.isFloat64Array; +function isNonIndex(key) { + if (key.length === 0 || key.length > 10) return true; + for (var i = 0; i < key.length; i++) { + var code = key.charCodeAt(i); + if (code < 48 || code > 57) return true; + } + // The maximum size for an array is 2 ** 32 -1. + return key.length === 10 && key >= Math.pow(2, 32); +} +function getOwnNonIndexProperties(value) { + return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value))); +} + +// Taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js +// original notice: +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ +function compare(a, b) { + 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; +} +var ONLY_ENUMERABLE = undefined; +var kStrict = true; +var kLoose = false; +var kNoIterator = 0; +var kIsArray = 1; +var kIsSet = 2; +var kIsMap = 3; + +// Check if they have the same source and flags +function areSimilarRegExps(a, b) { + return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b); +} +function areSimilarFloatArrays(a, b) { + if (a.byteLength !== b.byteLength) { + return false; + } + for (var offset = 0; offset < a.byteLength; offset++) { + if (a[offset] !== b[offset]) { + return false; + } + } + return true; +} +function areSimilarTypedArrays(a, b) { + if (a.byteLength !== b.byteLength) { + return false; + } + return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0; +} +function areEqualArrayBuffers(buf1, buf2) { + return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0; +} +function isEqualBoxedPrimitive(val1, val2) { + if (isNumberObject(val1)) { + return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2)); + } + if (isStringObject(val1)) { + return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2); + } + if (isBooleanObject(val1)) { + return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2); + } + if (isBigIntObject(val1)) { + return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2); + } + return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2); +} + +// Notes: Type tags are historical [[Class]] properties that can be set by +// FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS +// and retrieved using Object.prototype.toString.call(obj) in JS +// See https://tc39.github.io/ecma262/#sec-object.prototype.tostring +// for a list of tags pre-defined in the spec. +// There are some unspecified tags in the wild too (e.g. typed array tags). +// Since tags can be altered, they only serve fast failures +// +// Typed arrays and buffers are checked by comparing the content in their +// underlying ArrayBuffer. This optimization requires that it's +// reasonable to interpret their underlying memory in the same way, +// which is checked by comparing their type tags. +// (e.g. a Uint8Array and a Uint16Array with the same memory content +// could still be different because they will be interpreted differently). +// +// For strict comparison, objects should have +// a) The same built-in type tags +// b) The same prototypes. + +function innerDeepEqual(val1, val2, strict, memos) { + // All identical values are equivalent, as determined by ===. + if (val1 === val2) { + if (val1 !== 0) return true; + return strict ? objectIs(val1, val2) : true; + } + + // Check more closely if val1 and val2 are equal. + if (strict) { + if (_typeof(val1) !== 'object') { + return typeof val1 === 'number' && numberIsNaN(val1) && numberIsNaN(val2); + } + if (_typeof(val2) !== 'object' || val1 === null || val2 === null) { + return false; + } + if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) { + return false; + } + } else { + if (val1 === null || _typeof(val1) !== 'object') { + if (val2 === null || _typeof(val2) !== 'object') { + // eslint-disable-next-line eqeqeq + return val1 == val2; + } + return false; + } + if (val2 === null || _typeof(val2) !== 'object') { + return false; + } + } + var val1Tag = objectToString(val1); + var val2Tag = objectToString(val2); + if (val1Tag !== val2Tag) { + return false; + } + if (Array.isArray(val1)) { + // Check for sparse arrays and general fast path + if (val1.length !== val2.length) { + return false; + } + var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE); + var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE); + if (keys1.length !== keys2.length) { + return false; + } + return keyCheck(val1, val2, strict, memos, kIsArray, keys1); + } + // [browserify] This triggers on certain types in IE (Map/Set) so we don't + // wan't to early return out of the rest of the checks. However we can check + // if the second value is one of these values and the first isn't. + if (val1Tag === '[object Object]') { + // return keyCheck(val1, val2, strict, memos, kNoIterator); + if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) { + return false; + } + } + if (isDate(val1)) { + if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) { + return false; + } + } else if (isRegExp(val1)) { + if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) { + return false; + } + } else if (isNativeError(val1) || val1 instanceof Error) { + // Do not compare the stack as it might differ even though the error itself + // is otherwise identical. + if (val1.message !== val2.message || val1.name !== val2.name) { + return false; + } + } else if (isArrayBufferView(val1)) { + if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) { + if (!areSimilarFloatArrays(val1, val2)) { + return false; + } + } else if (!areSimilarTypedArrays(val1, val2)) { + return false; + } + // Buffer.compare returns true, so val1.length === val2.length. If they both + // only contain numeric keys, we don't need to exam further than checking + // the symbols. + var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE); + var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE); + if (_keys.length !== _keys2.length) { + return false; + } + return keyCheck(val1, val2, strict, memos, kNoIterator, _keys); + } else if (isSet(val1)) { + if (!isSet(val2) || val1.size !== val2.size) { + return false; + } + return keyCheck(val1, val2, strict, memos, kIsSet); + } else if (isMap(val1)) { + if (!isMap(val2) || val1.size !== val2.size) { + return false; + } + return keyCheck(val1, val2, strict, memos, kIsMap); + } else if (isAnyArrayBuffer(val1)) { + if (!areEqualArrayBuffers(val1, val2)) { + return false; + } + } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) { + return false; + } + return keyCheck(val1, val2, strict, memos, kNoIterator); +} +function getEnumerables(val, keys) { + return keys.filter(function (k) { + return propertyIsEnumerable(val, k); + }); +} +function keyCheck(val1, val2, strict, memos, iterationType, aKeys) { + // For all remaining Object pairs, including Array, objects and Maps, + // equivalence is determined by having: + // a) The same number of owned enumerable properties + // b) The same set of keys/indexes (although not necessarily the same order) + // c) Equivalent values for every corresponding key/index + // d) For Sets and Maps, equal contents + // Note: this accounts for both named and indexed properties on Arrays. + if (arguments.length === 5) { + aKeys = Object.keys(val1); + var bKeys = Object.keys(val2); + + // The pair must have the same number of owned properties. + if (aKeys.length !== bKeys.length) { + return false; + } + } + + // Cheap key test + var i = 0; + for (; i < aKeys.length; i++) { + if (!hasOwnProperty(val2, aKeys[i])) { + return false; + } + } + if (strict && arguments.length === 5) { + var symbolKeysA = objectGetOwnPropertySymbols(val1); + if (symbolKeysA.length !== 0) { + var count = 0; + for (i = 0; i < symbolKeysA.length; i++) { + var key = symbolKeysA[i]; + if (propertyIsEnumerable(val1, key)) { + if (!propertyIsEnumerable(val2, key)) { + return false; + } + aKeys.push(key); + count++; + } else if (propertyIsEnumerable(val2, key)) { + return false; + } + } + var symbolKeysB = objectGetOwnPropertySymbols(val2); + if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) { + return false; + } + } else { + var _symbolKeysB = objectGetOwnPropertySymbols(val2); + if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) { + return false; + } + } + } + if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) { + return true; + } + + // Use memos to handle cycles. + if (memos === undefined) { + memos = { + val1: new Map(), + val2: new Map(), + position: 0 + }; + } else { + // We prevent up to two map.has(x) calls by directly retrieving the value + // and checking for undefined. The map can only contain numbers, so it is + // safe to check for undefined only. + var val2MemoA = memos.val1.get(val1); + if (val2MemoA !== undefined) { + var val2MemoB = memos.val2.get(val2); + if (val2MemoB !== undefined) { + return val2MemoA === val2MemoB; + } + } + memos.position++; + } + memos.val1.set(val1, memos.position); + memos.val2.set(val2, memos.position); + var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType); + memos.val1.delete(val1); + memos.val2.delete(val2); + return areEq; +} +function setHasEqualElement(set, val1, strict, memo) { + // Go looking. + var setValues = arrayFromSet(set); + for (var i = 0; i < setValues.length; i++) { + var val2 = setValues[i]; + if (innerDeepEqual(val1, val2, strict, memo)) { + // Remove the matching element to make sure we do not check that again. + set.delete(val2); + return true; + } + } + return false; +} + +// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Loose_equality_using +// Sadly it is not possible to detect corresponding values properly in case the +// type is a string, number, bigint or boolean. The reason is that those values +// can match lots of different string values (e.g., 1n == '+00001'). +function findLooseMatchingPrimitives(prim) { + switch (_typeof(prim)) { + case 'undefined': + return null; + case 'object': + // Only pass in null as object! + return undefined; + case 'symbol': + return false; + case 'string': + prim = +prim; + // Loose equal entries exist only if the string is possible to convert to + // a regular number and not NaN. + // Fall through + case 'number': + if (numberIsNaN(prim)) { + return false; + } + } + return true; +} +function setMightHaveLoosePrim(a, b, prim) { + var altValue = findLooseMatchingPrimitives(prim); + if (altValue != null) return altValue; + return b.has(altValue) && !a.has(altValue); +} +function mapMightHaveLoosePrim(a, b, prim, item, memo) { + var altValue = findLooseMatchingPrimitives(prim); + if (altValue != null) { + return altValue; + } + var curB = b.get(altValue); + if (curB === undefined && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) { + return false; + } + return !a.has(altValue) && innerDeepEqual(item, curB, false, memo); +} +function setEquiv(a, b, strict, memo) { + // This is a lazily initiated Set of entries which have to be compared + // pairwise. + var set = null; + var aValues = arrayFromSet(a); + for (var i = 0; i < aValues.length; i++) { + var val = aValues[i]; + // Note: Checking for the objects first improves the performance for object + // heavy sets but it is a minor slow down for primitives. As they are fast + // to check this improves the worst case scenario instead. + if (_typeof(val) === 'object' && val !== null) { + if (set === null) { + set = new Set(); + } + // If the specified value doesn't exist in the second set its an not null + // object (or non strict only: a not matching primitive) we'll need to go + // hunting for something thats deep-(strict-)equal to it. To make this + // O(n log n) complexity we have to copy these values in a new set first. + set.add(val); + } else if (!b.has(val)) { + if (strict) return false; + + // Fast path to detect missing string, symbol, undefined and null values. + if (!setMightHaveLoosePrim(a, b, val)) { + return false; + } + if (set === null) { + set = new Set(); + } + set.add(val); + } + } + if (set !== null) { + var bValues = arrayFromSet(b); + for (var _i = 0; _i < bValues.length; _i++) { + var _val = bValues[_i]; + // We have to check if a primitive value is already + // matching and only if it's not, go hunting for it. + if (_typeof(_val) === 'object' && _val !== null) { + if (!setHasEqualElement(set, _val, strict, memo)) return false; + } else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) { + return false; + } + } + return set.size === 0; + } + return true; +} +function mapHasEqualEntry(set, map, key1, item1, strict, memo) { + // To be able to handle cases like: + // Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']]) + // ... we need to consider *all* matching keys, not just the first we find. + var setValues = arrayFromSet(set); + for (var i = 0; i < setValues.length; i++) { + var key2 = setValues[i]; + if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) { + set.delete(key2); + return true; + } + } + return false; +} +function mapEquiv(a, b, strict, memo) { + var set = null; + var aEntries = arrayFromMap(a); + for (var i = 0; i < aEntries.length; i++) { + var _aEntries$i = _slicedToArray(aEntries[i], 2), + key = _aEntries$i[0], + item1 = _aEntries$i[1]; + if (_typeof(key) === 'object' && key !== null) { + if (set === null) { + set = new Set(); + } + set.add(key); + } else { + // By directly retrieving the value we prevent another b.has(key) check in + // almost all possible cases. + var item2 = b.get(key); + if (item2 === undefined && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) { + if (strict) return false; + // Fast path to detect missing string, symbol, undefined and null + // keys. + if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false; + if (set === null) { + set = new Set(); + } + set.add(key); + } + } + } + if (set !== null) { + var bEntries = arrayFromMap(b); + for (var _i2 = 0; _i2 < bEntries.length; _i2++) { + var _bEntries$_i = _slicedToArray(bEntries[_i2], 2), + _key = _bEntries$_i[0], + item = _bEntries$_i[1]; + if (_typeof(_key) === 'object' && _key !== null) { + if (!mapHasEqualEntry(set, a, _key, item, strict, memo)) return false; + } else if (!strict && (!a.has(_key) || !innerDeepEqual(a.get(_key), item, false, memo)) && !mapHasEqualEntry(set, a, _key, item, false, memo)) { + return false; + } + } + return set.size === 0; + } + return true; +} +function objEquiv(a, b, strict, keys, memos, iterationType) { + // Sets and maps don't have their entries accessible via normal object + // properties. + var i = 0; + if (iterationType === kIsSet) { + if (!setEquiv(a, b, strict, memos)) { + return false; + } + } else if (iterationType === kIsMap) { + if (!mapEquiv(a, b, strict, memos)) { + return false; + } + } else if (iterationType === kIsArray) { + for (; i < a.length; i++) { + if (hasOwnProperty(a, i)) { + if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) { + return false; + } + } else if (hasOwnProperty(b, i)) { + return false; + } else { + // Array is sparse. + var keysA = Object.keys(a); + for (; i < keysA.length; i++) { + var key = keysA[i]; + if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) { + return false; + } + } + if (keysA.length !== Object.keys(b).length) { + return false; + } + return true; + } + } + } + + // The pair must have equivalent values for every corresponding key. + // Possibly expensive deep test: + for (i = 0; i < keys.length; i++) { + var _key2 = keys[i]; + if (!innerDeepEqual(a[_key2], b[_key2], strict, memos)) { + return false; + } + } + return true; +} +function isDeepEqual(val1, val2) { + return innerDeepEqual(val1, val2, kLoose); +} +function isDeepStrictEqual(val1, val2) { + return innerDeepEqual(val1, val2, kStrict); +} +module.exports = { + isDeepEqual: isDeepEqual, + isDeepStrictEqual: isDeepStrictEqual +}; + +/***/ }, + +/***/ 2504 +(__unused_webpack_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('') +} + + +/***/ }, + +/***/ 4097 +(module) { + +/* 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; + + +/***/ }, + +/***/ 7043 +(__unused_webpack_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, +]); + + +/***/ }, + +/***/ 980 +(__unused_webpack_module, exports, __webpack_require__) { + +var __webpack_unused_export__; +/* 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 = (__webpack_require__(8197)/* .BrotliInput */ .z); +var BrotliOutput = (__webpack_require__(8197)/* .BrotliOutput */ .y); +var BrotliBitReader = __webpack_require__(4097); +var BrotliDictionary = __webpack_require__(614); +var HuffmanCode = (__webpack_require__(1561)/* .HuffmanCode */ .z); +var BrotliBuildHuffmanTable = (__webpack_require__(1561)/* .BrotliBuildHuffmanTable */ .u); +var Context = __webpack_require__(7043); +var Prefix = __webpack_require__(2210); +var Transform = __webpack_require__(7984); + +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; +} + +__webpack_unused_export__ = 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); +} + +__webpack_unused_export__ = BrotliDecompress; + +BrotliDictionary.init(); + + +/***/ }, + +/***/ 4543 +(__unused_webpack_module, exports, __webpack_require__) { + +var base64 = __webpack_require__(2504); + +/** + * 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 = (__webpack_require__(980).BrotliDecompressBuffer); + var compressed = base64.toByteArray(__webpack_require__(3501)); + return BrotliDecompressBuffer(compressed); +}; + + +/***/ }, + +/***/ 3501 +(module) { + +module.exports="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"; + + +/***/ }, + +/***/ 614 +(__unused_webpack_module, exports, __webpack_require__) { + +/* 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 = __webpack_require__(4543); +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; + + +/***/ }, + +/***/ 1561 +(__unused_webpack_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.z = 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.u = 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; +} + + +/***/ }, + +/***/ 2210 +(__unused_webpack_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, +]; + + +/***/ }, + +/***/ 8197 +(__unused_webpack_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.z = 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.y = BrotliOutput; + + +/***/ }, + +/***/ 7984 +(__unused_webpack_module, exports, __webpack_require__) { + +/* 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 = __webpack_require__(614); + +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; +} + + +/***/ }, + +/***/ 4460 +(module, __unused_webpack_exports, __webpack_require__) { + +module.exports = __webpack_require__(980).BrotliDecompressBuffer; + + +/***/ }, + +/***/ 2908 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var Buffer = __webpack_require__(783)["Buffer"]; +/* provided dependency */ var process = __webpack_require__(9964); + +/* eslint camelcase: "off" */ + +var assert = __webpack_require__(7801); + +var Zstream = __webpack_require__(7468); +var zlib_deflate = __webpack_require__(2925); +var zlib_inflate = __webpack_require__(2269); +var constants = __webpack_require__(1607); + +for (var key in constants) { + exports[key] = constants[key]; +} + +// zlib modes +exports.NONE = 0; +exports.DEFLATE = 1; +exports.INFLATE = 2; +exports.GZIP = 3; +exports.GUNZIP = 4; +exports.DEFLATERAW = 5; +exports.INFLATERAW = 6; +exports.UNZIP = 7; + +var GZIP_HEADER_ID1 = 0x1f; +var GZIP_HEADER_ID2 = 0x8b; + +/** + * Emulate Node's zlib C++ layer for use by the JS layer in index.js + */ +function Zlib(mode) { + if (typeof mode !== 'number' || mode < exports.DEFLATE || mode > exports.UNZIP) { + throw new TypeError('Bad argument'); + } + + this.dictionary = null; + this.err = 0; + this.flush = 0; + this.init_done = false; + this.level = 0; + this.memLevel = 0; + this.mode = mode; + this.strategy = 0; + this.windowBits = 0; + this.write_in_progress = false; + this.pending_close = false; + this.gzip_id_bytes_read = 0; +} + +Zlib.prototype.close = function () { + if (this.write_in_progress) { + this.pending_close = true; + return; + } + + this.pending_close = false; + + assert(this.init_done, 'close before init'); + assert(this.mode <= exports.UNZIP); + + if (this.mode === exports.DEFLATE || this.mode === exports.GZIP || this.mode === exports.DEFLATERAW) { + zlib_deflate.deflateEnd(this.strm); + } else if (this.mode === exports.INFLATE || this.mode === exports.GUNZIP || this.mode === exports.INFLATERAW || this.mode === exports.UNZIP) { + zlib_inflate.inflateEnd(this.strm); + } + + this.mode = exports.NONE; + + this.dictionary = null; +}; + +Zlib.prototype.write = function (flush, input, in_off, in_len, out, out_off, out_len) { + return this._write(true, flush, input, in_off, in_len, out, out_off, out_len); +}; + +Zlib.prototype.writeSync = function (flush, input, in_off, in_len, out, out_off, out_len) { + return this._write(false, flush, input, in_off, in_len, out, out_off, out_len); +}; + +Zlib.prototype._write = function (async, flush, input, in_off, in_len, out, out_off, out_len) { + assert.equal(arguments.length, 8); + + assert(this.init_done, 'write before init'); + assert(this.mode !== exports.NONE, 'already finalized'); + assert.equal(false, this.write_in_progress, 'write already in progress'); + assert.equal(false, this.pending_close, 'close is pending'); + + this.write_in_progress = true; + + assert.equal(false, flush === undefined, 'must provide flush value'); + + this.write_in_progress = true; + + if (flush !== exports.Z_NO_FLUSH && flush !== exports.Z_PARTIAL_FLUSH && flush !== exports.Z_SYNC_FLUSH && flush !== exports.Z_FULL_FLUSH && flush !== exports.Z_FINISH && flush !== exports.Z_BLOCK) { + throw new Error('Invalid flush value'); + } + + if (input == null) { + input = Buffer.alloc(0); + in_len = 0; + in_off = 0; + } + + this.strm.avail_in = in_len; + this.strm.input = input; + this.strm.next_in = in_off; + this.strm.avail_out = out_len; + this.strm.output = out; + this.strm.next_out = out_off; + this.flush = flush; + + if (!async) { + // sync version + this._process(); + + if (this._checkError()) { + return this._afterSync(); + } + return; + } + + // async version + var self = this; + process.nextTick(function () { + self._process(); + self._after(); + }); + + return this; +}; + +Zlib.prototype._afterSync = function () { + var avail_out = this.strm.avail_out; + var avail_in = this.strm.avail_in; + + this.write_in_progress = false; + + return [avail_in, avail_out]; +}; + +Zlib.prototype._process = function () { + var next_expected_header_byte = null; + + // If the avail_out is left at 0, then it means that it ran out + // of room. If there was avail_out left over, then it means + // that all of the input was consumed. + switch (this.mode) { + case exports.DEFLATE: + case exports.GZIP: + case exports.DEFLATERAW: + this.err = zlib_deflate.deflate(this.strm, this.flush); + break; + case exports.UNZIP: + if (this.strm.avail_in > 0) { + next_expected_header_byte = this.strm.next_in; + } + + switch (this.gzip_id_bytes_read) { + case 0: + if (next_expected_header_byte === null) { + break; + } + + if (this.strm.input[next_expected_header_byte] === GZIP_HEADER_ID1) { + this.gzip_id_bytes_read = 1; + next_expected_header_byte++; + + if (this.strm.avail_in === 1) { + // The only available byte was already read. + break; + } + } else { + this.mode = exports.INFLATE; + break; + } + + // fallthrough + case 1: + if (next_expected_header_byte === null) { + break; + } + + if (this.strm.input[next_expected_header_byte] === GZIP_HEADER_ID2) { + this.gzip_id_bytes_read = 2; + this.mode = exports.GUNZIP; + } else { + // There is no actual difference between INFLATE and INFLATERAW + // (after initialization). + this.mode = exports.INFLATE; + } + + break; + default: + throw new Error('invalid number of gzip magic number bytes read'); + } + + // fallthrough + case exports.INFLATE: + case exports.GUNZIP: + case exports.INFLATERAW: + this.err = zlib_inflate.inflate(this.strm, this.flush + + // If data was encoded with dictionary + );if (this.err === exports.Z_NEED_DICT && this.dictionary) { + // Load it + this.err = zlib_inflate.inflateSetDictionary(this.strm, this.dictionary); + if (this.err === exports.Z_OK) { + // And try to decode again + this.err = zlib_inflate.inflate(this.strm, this.flush); + } else if (this.err === exports.Z_DATA_ERROR) { + // Both inflateSetDictionary() and inflate() return Z_DATA_ERROR. + // Make it possible for After() to tell a bad dictionary from bad + // input. + this.err = exports.Z_NEED_DICT; + } + } + while (this.strm.avail_in > 0 && this.mode === exports.GUNZIP && this.err === exports.Z_STREAM_END && this.strm.next_in[0] !== 0x00) { + // Bytes remain in input buffer. Perhaps this is another compressed + // member in the same archive, or just trailing garbage. + // Trailing zero bytes are okay, though, since they are frequently + // used for padding. + + this.reset(); + this.err = zlib_inflate.inflate(this.strm, this.flush); + } + break; + default: + throw new Error('Unknown mode ' + this.mode); + } +}; + +Zlib.prototype._checkError = function () { + // Acceptable error states depend on the type of zlib stream. + switch (this.err) { + case exports.Z_OK: + case exports.Z_BUF_ERROR: + if (this.strm.avail_out !== 0 && this.flush === exports.Z_FINISH) { + this._error('unexpected end of file'); + return false; + } + break; + case exports.Z_STREAM_END: + // normal statuses, not fatal + break; + case exports.Z_NEED_DICT: + if (this.dictionary == null) { + this._error('Missing dictionary'); + } else { + this._error('Bad dictionary'); + } + return false; + default: + // something else. + this._error('Zlib error'); + return false; + } + + return true; +}; + +Zlib.prototype._after = function () { + if (!this._checkError()) { + return; + } + + var avail_out = this.strm.avail_out; + var avail_in = this.strm.avail_in; + + this.write_in_progress = false; + + // call the write() cb + this.callback(avail_in, avail_out); + + if (this.pending_close) { + this.close(); + } +}; + +Zlib.prototype._error = function (message) { + if (this.strm.msg) { + message = this.strm.msg; + } + this.onerror(message, this.err + + // no hope of rescue. + );this.write_in_progress = false; + if (this.pending_close) { + this.close(); + } +}; + +Zlib.prototype.init = function (windowBits, level, memLevel, strategy, dictionary) { + assert(arguments.length === 4 || arguments.length === 5, 'init(windowBits, level, memLevel, strategy, [dictionary])'); + + assert(windowBits >= 8 && windowBits <= 15, 'invalid windowBits'); + assert(level >= -1 && level <= 9, 'invalid compression level'); + + assert(memLevel >= 1 && memLevel <= 9, 'invalid memlevel'); + + assert(strategy === exports.Z_FILTERED || strategy === exports.Z_HUFFMAN_ONLY || strategy === exports.Z_RLE || strategy === exports.Z_FIXED || strategy === exports.Z_DEFAULT_STRATEGY, 'invalid strategy'); + + this._init(level, windowBits, memLevel, strategy, dictionary); + this._setDictionary(); +}; + +Zlib.prototype.params = function () { + throw new Error('deflateParams Not supported'); +}; + +Zlib.prototype.reset = function () { + this._reset(); + this._setDictionary(); +}; + +Zlib.prototype._init = function (level, windowBits, memLevel, strategy, dictionary) { + this.level = level; + this.windowBits = windowBits; + this.memLevel = memLevel; + this.strategy = strategy; + + this.flush = exports.Z_NO_FLUSH; + + this.err = exports.Z_OK; + + if (this.mode === exports.GZIP || this.mode === exports.GUNZIP) { + this.windowBits += 16; + } + + if (this.mode === exports.UNZIP) { + this.windowBits += 32; + } + + if (this.mode === exports.DEFLATERAW || this.mode === exports.INFLATERAW) { + this.windowBits = -1 * this.windowBits; + } + + this.strm = new Zstream(); + + switch (this.mode) { + case exports.DEFLATE: + case exports.GZIP: + case exports.DEFLATERAW: + this.err = zlib_deflate.deflateInit2(this.strm, this.level, exports.Z_DEFLATED, this.windowBits, this.memLevel, this.strategy); + break; + case exports.INFLATE: + case exports.GUNZIP: + case exports.INFLATERAW: + case exports.UNZIP: + this.err = zlib_inflate.inflateInit2(this.strm, this.windowBits); + break; + default: + throw new Error('Unknown mode ' + this.mode); + } + + if (this.err !== exports.Z_OK) { + this._error('Init error'); + } + + this.dictionary = dictionary; + + this.write_in_progress = false; + this.init_done = true; +}; + +Zlib.prototype._setDictionary = function () { + if (this.dictionary == null) { + return; + } + + this.err = exports.Z_OK; + + switch (this.mode) { + case exports.DEFLATE: + case exports.DEFLATERAW: + this.err = zlib_deflate.deflateSetDictionary(this.strm, this.dictionary); + break; + default: + break; + } + + if (this.err !== exports.Z_OK) { + this._error('Failed to set dictionary'); + } +}; + +Zlib.prototype._reset = function () { + this.err = exports.Z_OK; + + switch (this.mode) { + case exports.DEFLATE: + case exports.DEFLATERAW: + case exports.GZIP: + this.err = zlib_deflate.deflateReset(this.strm); + break; + case exports.INFLATE: + case exports.INFLATERAW: + case exports.GUNZIP: + this.err = zlib_inflate.inflateReset(this.strm); + break; + default: + break; + } + + if (this.err !== exports.Z_OK) { + this._error('Failed to reset stream'); + } +}; + +exports.Zlib = Zlib; + +/***/ }, + +/***/ 6729 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); + + +var Buffer = (__webpack_require__(783).Buffer); +var Transform = (__webpack_require__(9760).Transform); +var binding = __webpack_require__(2908); +var util = __webpack_require__(7187); +var assert = (__webpack_require__(7801).ok); +var kMaxLength = (__webpack_require__(783).kMaxLength); +var kRangeErrorMessage = 'Cannot create final Buffer. It would be larger ' + 'than 0x' + kMaxLength.toString(16) + ' bytes'; + +// zlib doesn't provide these, so kludge them in following the same +// const naming scheme zlib uses. +binding.Z_MIN_WINDOWBITS = 8; +binding.Z_MAX_WINDOWBITS = 15; +binding.Z_DEFAULT_WINDOWBITS = 15; + +// fewer than 64 bytes per chunk is stupid. +// technically it could work with as few as 8, but even 64 bytes +// is absurdly low. Usually a MB or more is best. +binding.Z_MIN_CHUNK = 64; +binding.Z_MAX_CHUNK = Infinity; +binding.Z_DEFAULT_CHUNK = 16 * 1024; + +binding.Z_MIN_MEMLEVEL = 1; +binding.Z_MAX_MEMLEVEL = 9; +binding.Z_DEFAULT_MEMLEVEL = 8; + +binding.Z_MIN_LEVEL = -1; +binding.Z_MAX_LEVEL = 9; +binding.Z_DEFAULT_LEVEL = binding.Z_DEFAULT_COMPRESSION; + +// expose all the zlib constants +var bkeys = Object.keys(binding); +for (var bk = 0; bk < bkeys.length; bk++) { + var bkey = bkeys[bk]; + if (bkey.match(/^Z/)) { + Object.defineProperty(exports, bkey, { + enumerable: true, value: binding[bkey], writable: false + }); + } +} + +// translation table for return codes. +var codes = { + Z_OK: binding.Z_OK, + Z_STREAM_END: binding.Z_STREAM_END, + Z_NEED_DICT: binding.Z_NEED_DICT, + Z_ERRNO: binding.Z_ERRNO, + Z_STREAM_ERROR: binding.Z_STREAM_ERROR, + Z_DATA_ERROR: binding.Z_DATA_ERROR, + Z_MEM_ERROR: binding.Z_MEM_ERROR, + Z_BUF_ERROR: binding.Z_BUF_ERROR, + Z_VERSION_ERROR: binding.Z_VERSION_ERROR +}; + +var ckeys = Object.keys(codes); +for (var ck = 0; ck < ckeys.length; ck++) { + var ckey = ckeys[ck]; + codes[codes[ckey]] = ckey; +} + +Object.defineProperty(exports, "codes", ({ + enumerable: true, value: Object.freeze(codes), writable: false +})); + +exports.Deflate = Deflate; +exports.Inflate = Inflate; +exports.Gzip = Gzip; +exports.Gunzip = Gunzip; +exports.DeflateRaw = DeflateRaw; +exports.InflateRaw = InflateRaw; +exports.Unzip = Unzip; + +exports.createDeflate = function (o) { + return new Deflate(o); +}; + +exports.createInflate = function (o) { + return new Inflate(o); +}; + +exports.createDeflateRaw = function (o) { + return new DeflateRaw(o); +}; + +exports.createInflateRaw = function (o) { + return new InflateRaw(o); +}; + +exports.createGzip = function (o) { + return new Gzip(o); +}; + +exports.createGunzip = function (o) { + return new Gunzip(o); +}; + +exports.createUnzip = function (o) { + return new Unzip(o); +}; + +// Convenience methods. +// compress/decompress a string or buffer in one step. +exports.deflate = function (buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Deflate(opts), buffer, callback); +}; + +exports.deflateSync = function (buffer, opts) { + return zlibBufferSync(new Deflate(opts), buffer); +}; + +exports.gzip = function (buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Gzip(opts), buffer, callback); +}; + +exports.gzipSync = function (buffer, opts) { + return zlibBufferSync(new Gzip(opts), buffer); +}; + +exports.deflateRaw = function (buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new DeflateRaw(opts), buffer, callback); +}; + +exports.deflateRawSync = function (buffer, opts) { + return zlibBufferSync(new DeflateRaw(opts), buffer); +}; + +exports.unzip = function (buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Unzip(opts), buffer, callback); +}; + +exports.unzipSync = function (buffer, opts) { + return zlibBufferSync(new Unzip(opts), buffer); +}; + +exports.inflate = function (buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Inflate(opts), buffer, callback); +}; + +exports.inflateSync = function (buffer, opts) { + return zlibBufferSync(new Inflate(opts), buffer); +}; + +exports.gunzip = function (buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new Gunzip(opts), buffer, callback); +}; + +exports.gunzipSync = function (buffer, opts) { + return zlibBufferSync(new Gunzip(opts), buffer); +}; + +exports.inflateRaw = function (buffer, opts, callback) { + if (typeof opts === 'function') { + callback = opts; + opts = {}; + } + return zlibBuffer(new InflateRaw(opts), buffer, callback); +}; + +exports.inflateRawSync = function (buffer, opts) { + return zlibBufferSync(new InflateRaw(opts), buffer); +}; + +function zlibBuffer(engine, buffer, callback) { + var buffers = []; + var nread = 0; + + engine.on('error', onError); + engine.on('end', onEnd); + + engine.end(buffer); + flow(); + + function flow() { + var chunk; + while (null !== (chunk = engine.read())) { + buffers.push(chunk); + nread += chunk.length; + } + engine.once('readable', flow); + } + + function onError(err) { + engine.removeListener('end', onEnd); + engine.removeListener('readable', flow); + callback(err); + } + + function onEnd() { + var buf; + var err = null; + + if (nread >= kMaxLength) { + err = new RangeError(kRangeErrorMessage); + } else { + buf = Buffer.concat(buffers, nread); + } + + buffers = []; + engine.close(); + callback(err, buf); + } +} + +function zlibBufferSync(engine, buffer) { + if (typeof buffer === 'string') buffer = Buffer.from(buffer); + + if (!Buffer.isBuffer(buffer)) throw new TypeError('Not a string or buffer'); + + var flushFlag = engine._finishFlushFlag; + + return engine._processChunk(buffer, flushFlag); +} + +// generic zlib +// minimal 2-byte header +function Deflate(opts) { + if (!(this instanceof Deflate)) return new Deflate(opts); + Zlib.call(this, opts, binding.DEFLATE); +} + +function Inflate(opts) { + if (!(this instanceof Inflate)) return new Inflate(opts); + Zlib.call(this, opts, binding.INFLATE); +} + +// gzip - bigger header, same deflate compression +function Gzip(opts) { + if (!(this instanceof Gzip)) return new Gzip(opts); + Zlib.call(this, opts, binding.GZIP); +} + +function Gunzip(opts) { + if (!(this instanceof Gunzip)) return new Gunzip(opts); + Zlib.call(this, opts, binding.GUNZIP); +} + +// raw - no header +function DeflateRaw(opts) { + if (!(this instanceof DeflateRaw)) return new DeflateRaw(opts); + Zlib.call(this, opts, binding.DEFLATERAW); +} + +function InflateRaw(opts) { + if (!(this instanceof InflateRaw)) return new InflateRaw(opts); + Zlib.call(this, opts, binding.INFLATERAW); +} + +// auto-detect header. +function Unzip(opts) { + if (!(this instanceof Unzip)) return new Unzip(opts); + Zlib.call(this, opts, binding.UNZIP); +} + +function isValidFlushFlag(flag) { + return flag === binding.Z_NO_FLUSH || flag === binding.Z_PARTIAL_FLUSH || flag === binding.Z_SYNC_FLUSH || flag === binding.Z_FULL_FLUSH || flag === binding.Z_FINISH || flag === binding.Z_BLOCK; +} + +// the Zlib class they all inherit from +// This thing manages the queue of requests, and returns +// true or false if there is anything in the queue when +// you call the .write() method. + +function Zlib(opts, mode) { + var _this = this; + + this._opts = opts = opts || {}; + this._chunkSize = opts.chunkSize || exports.Z_DEFAULT_CHUNK; + + Transform.call(this, opts); + + if (opts.flush && !isValidFlushFlag(opts.flush)) { + throw new Error('Invalid flush flag: ' + opts.flush); + } + if (opts.finishFlush && !isValidFlushFlag(opts.finishFlush)) { + throw new Error('Invalid flush flag: ' + opts.finishFlush); + } + + this._flushFlag = opts.flush || binding.Z_NO_FLUSH; + this._finishFlushFlag = typeof opts.finishFlush !== 'undefined' ? opts.finishFlush : binding.Z_FINISH; + + if (opts.chunkSize) { + if (opts.chunkSize < exports.Z_MIN_CHUNK || opts.chunkSize > exports.Z_MAX_CHUNK) { + throw new Error('Invalid chunk size: ' + opts.chunkSize); + } + } + + if (opts.windowBits) { + if (opts.windowBits < exports.Z_MIN_WINDOWBITS || opts.windowBits > exports.Z_MAX_WINDOWBITS) { + throw new Error('Invalid windowBits: ' + opts.windowBits); + } + } + + if (opts.level) { + if (opts.level < exports.Z_MIN_LEVEL || opts.level > exports.Z_MAX_LEVEL) { + throw new Error('Invalid compression level: ' + opts.level); + } + } + + if (opts.memLevel) { + if (opts.memLevel < exports.Z_MIN_MEMLEVEL || opts.memLevel > exports.Z_MAX_MEMLEVEL) { + throw new Error('Invalid memLevel: ' + opts.memLevel); + } + } + + if (opts.strategy) { + if (opts.strategy != exports.Z_FILTERED && opts.strategy != exports.Z_HUFFMAN_ONLY && opts.strategy != exports.Z_RLE && opts.strategy != exports.Z_FIXED && opts.strategy != exports.Z_DEFAULT_STRATEGY) { + throw new Error('Invalid strategy: ' + opts.strategy); + } + } + + if (opts.dictionary) { + if (!Buffer.isBuffer(opts.dictionary)) { + throw new Error('Invalid dictionary: it should be a Buffer instance'); + } + } + + this._handle = new binding.Zlib(mode); + + var self = this; + this._hadError = false; + this._handle.onerror = function (message, errno) { + // there is no way to cleanly recover. + // continuing only obscures problems. + _close(self); + self._hadError = true; + + var error = new Error(message); + error.errno = errno; + error.code = exports.codes[errno]; + self.emit('error', error); + }; + + var level = exports.Z_DEFAULT_COMPRESSION; + if (typeof opts.level === 'number') level = opts.level; + + var strategy = exports.Z_DEFAULT_STRATEGY; + if (typeof opts.strategy === 'number') strategy = opts.strategy; + + this._handle.init(opts.windowBits || exports.Z_DEFAULT_WINDOWBITS, level, opts.memLevel || exports.Z_DEFAULT_MEMLEVEL, strategy, opts.dictionary); + + this._buffer = Buffer.allocUnsafe(this._chunkSize); + this._offset = 0; + this._level = level; + this._strategy = strategy; + + this.once('end', this.close); + + Object.defineProperty(this, '_closed', { + get: function () { + return !_this._handle; + }, + configurable: true, + enumerable: true + }); +} + +util.inherits(Zlib, Transform); + +Zlib.prototype.params = function (level, strategy, callback) { + if (level < exports.Z_MIN_LEVEL || level > exports.Z_MAX_LEVEL) { + throw new RangeError('Invalid compression level: ' + level); + } + if (strategy != exports.Z_FILTERED && strategy != exports.Z_HUFFMAN_ONLY && strategy != exports.Z_RLE && strategy != exports.Z_FIXED && strategy != exports.Z_DEFAULT_STRATEGY) { + throw new TypeError('Invalid strategy: ' + strategy); + } + + if (this._level !== level || this._strategy !== strategy) { + var self = this; + this.flush(binding.Z_SYNC_FLUSH, function () { + assert(self._handle, 'zlib binding closed'); + self._handle.params(level, strategy); + if (!self._hadError) { + self._level = level; + self._strategy = strategy; + if (callback) callback(); + } + }); + } else { + process.nextTick(callback); + } +}; + +Zlib.prototype.reset = function () { + assert(this._handle, 'zlib binding closed'); + return this._handle.reset(); +}; + +// This is the _flush function called by the transform class, +// internally, when the last chunk has been written. +Zlib.prototype._flush = function (callback) { + this._transform(Buffer.alloc(0), '', callback); +}; + +Zlib.prototype.flush = function (kind, callback) { + var _this2 = this; + + var ws = this._writableState; + + if (typeof kind === 'function' || kind === undefined && !callback) { + callback = kind; + kind = binding.Z_FULL_FLUSH; + } + + if (ws.ended) { + if (callback) process.nextTick(callback); + } else if (ws.ending) { + if (callback) this.once('end', callback); + } else if (ws.needDrain) { + if (callback) { + this.once('drain', function () { + return _this2.flush(kind, callback); + }); + } + } else { + this._flushFlag = kind; + this.write(Buffer.alloc(0), '', callback); + } +}; + +Zlib.prototype.close = function (callback) { + _close(this, callback); + process.nextTick(emitCloseNT, this); +}; + +function _close(engine, callback) { + if (callback) process.nextTick(callback); + + // Caller may invoke .close after a zlib error (which will null _handle). + if (!engine._handle) return; + + engine._handle.close(); + engine._handle = null; +} + +function emitCloseNT(self) { + self.emit('close'); +} + +Zlib.prototype._transform = function (chunk, encoding, cb) { + var flushFlag; + var ws = this._writableState; + var ending = ws.ending || ws.ended; + var last = ending && (!chunk || ws.length === chunk.length); + + if (chunk !== null && !Buffer.isBuffer(chunk)) return cb(new Error('invalid input')); + + if (!this._handle) return cb(new Error('zlib binding closed')); + + // If it's the last chunk, or a final flush, we use the Z_FINISH flush flag + // (or whatever flag was provided using opts.finishFlush). + // If it's explicitly flushing at some other time, then we use + // Z_FULL_FLUSH. Otherwise, use Z_NO_FLUSH for maximum compression + // goodness. + if (last) flushFlag = this._finishFlushFlag;else { + flushFlag = this._flushFlag; + // once we've flushed the last of the queue, stop flushing and + // go back to the normal behavior. + if (chunk.length >= ws.length) { + this._flushFlag = this._opts.flush || binding.Z_NO_FLUSH; + } + } + + this._processChunk(chunk, flushFlag, cb); +}; + +Zlib.prototype._processChunk = function (chunk, flushFlag, cb) { + var availInBefore = chunk && chunk.length; + var availOutBefore = this._chunkSize - this._offset; + var inOff = 0; + + var self = this; + + var async = typeof cb === 'function'; + + if (!async) { + var buffers = []; + var nread = 0; + + var error; + this.on('error', function (er) { + error = er; + }); + + assert(this._handle, 'zlib binding closed'); + do { + var res = this._handle.writeSync(flushFlag, chunk, // in + inOff, // in_off + availInBefore, // in_len + this._buffer, // out + this._offset, //out_off + availOutBefore); // out_len + } while (!this._hadError && callback(res[0], res[1])); + + if (this._hadError) { + throw error; + } + + if (nread >= kMaxLength) { + _close(this); + throw new RangeError(kRangeErrorMessage); + } + + var buf = Buffer.concat(buffers, nread); + _close(this); + + return buf; + } + + assert(this._handle, 'zlib binding closed'); + var req = this._handle.write(flushFlag, chunk, // in + inOff, // in_off + availInBefore, // in_len + this._buffer, // out + this._offset, //out_off + availOutBefore); // out_len + + req.buffer = chunk; + req.callback = callback; + + function callback(availInAfter, availOutAfter) { + // When the callback is used in an async write, the callback's + // context is the `req` object that was created. The req object + // is === this._handle, and that's why it's important to null + // out the values after they are done being used. `this._handle` + // can stay in memory longer than the callback and buffer are needed. + if (this) { + this.buffer = null; + this.callback = null; + } + + if (self._hadError) return; + + var have = availOutBefore - availOutAfter; + assert(have >= 0, 'have should not go down'); + + if (have > 0) { + var out = self._buffer.slice(self._offset, self._offset + have); + self._offset += have; + // serve some output to the consumer. + if (async) { + self.push(out); + } else { + buffers.push(out); + nread += out.length; + } + } + + // exhausted the output buffer, or used all the input create a new one. + if (availOutAfter === 0 || self._offset >= self._chunkSize) { + availOutBefore = self._chunkSize; + self._offset = 0; + self._buffer = Buffer.allocUnsafe(self._chunkSize); + } + + if (availOutAfter === 0) { + // Not actually done. Need to reprocess. + // Also, update the availInBefore to the availInAfter value, + // so that if we have to hit it a third (fourth, etc.) time, + // it'll have the correct byte counts. + inOff += availInBefore - availInAfter; + availInBefore = availInAfter; + + if (!async) return true; + + var newReq = self._handle.write(flushFlag, chunk, inOff, availInBefore, self._buffer, self._offset, self._chunkSize); + newReq.callback = callback; // this same function + newReq.buffer = chunk; + return; + } + + if (!async) return false; + + // finished with the chunk. + cb(); + } +}; + +util.inherits(Deflate, Zlib); +util.inherits(Inflate, Zlib); +util.inherits(Gzip, Zlib); +util.inherits(Gunzip, Zlib); +util.inherits(DeflateRaw, Zlib); +util.inherits(InflateRaw, Zlib); +util.inherits(Unzip, Zlib); + +/***/ }, + +/***/ 7802 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var bind = __webpack_require__(5049); + +var $apply = __webpack_require__(3036); +var $call = __webpack_require__(78); +var $reflectApply = __webpack_require__(1909); + +/** @type {import('./actualApply')} */ +module.exports = $reflectApply || bind.call($call, $apply); + + +/***/ }, + +/***/ 8619 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var bind = __webpack_require__(5049); +var $apply = __webpack_require__(3036); +var actualApply = __webpack_require__(7802); + +/** @type {import('./applyBind')} */ +module.exports = function applyBind() { + return actualApply(bind, $apply, arguments); +}; + + +/***/ }, + +/***/ 3036 +(module) { + +"use strict"; + + +/** @type {import('./functionApply')} */ +module.exports = Function.prototype.apply; + + +/***/ }, + +/***/ 78 +(module) { + +"use strict"; + + +/** @type {import('./functionCall')} */ +module.exports = Function.prototype.call; + + +/***/ }, + +/***/ 6688 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var bind = __webpack_require__(5049); +var $TypeError = __webpack_require__(6785); + +var $call = __webpack_require__(78); +var $actualApply = __webpack_require__(7802); + +/** @type {(args: [Function, thisArg?: unknown, ...args: unknown[]]) => Function} TODO FIXME, find a way to use import('.') */ +module.exports = function callBindBasic(args) { + if (args.length < 1 || typeof args[0] !== 'function') { + throw new $TypeError('a function is required'); + } + return $actualApply(bind, $call, args); +}; + + +/***/ }, + +/***/ 1909 +(module) { + +"use strict"; + + +/** @type {import('./reflectApply')} */ +module.exports = typeof Reflect !== 'undefined' && Reflect && Reflect.apply; + + +/***/ }, + +/***/ 7913 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var GetIntrinsic = __webpack_require__(8651); + +var callBind = __webpack_require__(6601); + +var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf')); + +module.exports = function callBoundIntrinsic(name, allowMissing) { + var intrinsic = GetIntrinsic(name, !!allowMissing); + if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) { + return callBind(intrinsic); + } + return intrinsic; +}; + + +/***/ }, + +/***/ 6601 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var setFunctionLength = __webpack_require__(6255); + +var $defineProperty = __webpack_require__(6649); + +var callBindBasic = __webpack_require__(6688); +var applyBind = __webpack_require__(8619); + +module.exports = function callBind(originalFunction) { + var func = callBindBasic(arguments); + var adjustedLength = 1 + originalFunction.length - (arguments.length - 1); + return setFunctionLength( + func, + adjustedLength > 0 ? adjustedLength : 0, + true + ); +}; + +if ($defineProperty) { + $defineProperty(module.exports, 'apply', { value: applyBind }); +} else { + module.exports.apply = applyBind; +} + + +/***/ }, + +/***/ 2774 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var GetIntrinsic = __webpack_require__(8651); + +var callBindBasic = __webpack_require__(6688); + +/** @type {(thisArg: string, searchString: string, position?: number) => number} */ +var $indexOf = callBindBasic([GetIntrinsic('%String.prototype.indexOf%')]); + +/** @type {import('.')} */ +module.exports = function callBoundIntrinsic(name, allowMissing) { + /* eslint no-extra-parens: 0 */ + + var intrinsic = /** @type {(this: unknown, ...args: unknown[]) => unknown} */ (GetIntrinsic(name, !!allowMissing)); + if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) { + return callBindBasic(/** @type {const} */ ([intrinsic])); + } + return intrinsic; +}; + + +/***/ }, + +/***/ 1613 +(module, __unused_webpack_exports, __webpack_require__) { + +/* provided dependency */ var Buffer = __webpack_require__(783)["Buffer"]; +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 ( true && module.exports) { + module.exports = clone; +} + + +/***/ }, + +/***/ 9295 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var $defineProperty = __webpack_require__(6649); + +var $SyntaxError = __webpack_require__(7770); +var $TypeError = __webpack_require__(6785); + +var gopd = __webpack_require__(8109); + +/** @type {import('.')} */ +module.exports = function defineDataProperty( + obj, + property, + value +) { + if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) { + throw new $TypeError('`obj` must be an object or a function`'); + } + if (typeof property !== 'string' && typeof property !== 'symbol') { + throw new $TypeError('`property` must be a string or a symbol`'); + } + if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) { + throw new $TypeError('`nonEnumerable`, if provided, must be a boolean or null'); + } + if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) { + throw new $TypeError('`nonWritable`, if provided, must be a boolean or null'); + } + if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) { + throw new $TypeError('`nonConfigurable`, if provided, must be a boolean or null'); + } + if (arguments.length > 6 && typeof arguments[6] !== 'boolean') { + throw new $TypeError('`loose`, if provided, must be a boolean'); + } + + var nonEnumerable = arguments.length > 3 ? arguments[3] : null; + var nonWritable = arguments.length > 4 ? arguments[4] : null; + var nonConfigurable = arguments.length > 5 ? arguments[5] : null; + var loose = arguments.length > 6 ? arguments[6] : false; + + /* @type {false | TypedPropertyDescriptor} */ + var desc = !!gopd && gopd(obj, property); + + if ($defineProperty) { + $defineProperty(obj, property, { + configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable, + enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable, + value: value, + writable: nonWritable === null && desc ? desc.writable : !nonWritable + }); + } else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) { + // must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable + obj[property] = value; // eslint-disable-line no-param-reassign + } else { + throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.'); + } +}; + + +/***/ }, + +/***/ 5421 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var keys = __webpack_require__(5643); +var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol'; + +var toStr = Object.prototype.toString; +var concat = Array.prototype.concat; +var defineDataProperty = __webpack_require__(9295); + +var isFunction = function (fn) { + return typeof fn === 'function' && toStr.call(fn) === '[object Function]'; +}; + +var supportsDescriptors = __webpack_require__(8890)(); + +var defineProperty = function (object, name, value, predicate) { + if (name in object) { + if (predicate === true) { + if (object[name] === value) { + return; + } + } else if (!isFunction(predicate) || !predicate()) { + return; + } + } + + if (supportsDescriptors) { + defineDataProperty(object, name, value, true); + } else { + defineDataProperty(object, name, value); + } +}; + +var defineProperties = function (object, map) { + var predicates = arguments.length > 2 ? arguments[2] : {}; + var props = keys(map); + if (hasSymbols) { + props = concat.call(props, Object.getOwnPropertySymbols(map)); + } + for (var i = 0; i < props.length; i += 1) { + defineProperty(object, props[i], map[props[i]], predicates[props[i]]); + } +}; + +defineProperties.supportsDescriptors = !!supportsDescriptors; + +module.exports = defineProperties; + + +/***/ }, + +/***/ 9302 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var callBind = __webpack_require__(6688); +var gOPD = __webpack_require__(8109); + +var hasProtoAccessor; +try { + // eslint-disable-next-line no-extra-parens, no-proto + hasProtoAccessor = /** @type {{ __proto__?: typeof Array.prototype }} */ ([]).__proto__ === Array.prototype; +} catch (e) { + if (!e || typeof e !== 'object' || !('code' in e) || e.code !== 'ERR_PROTO_ACCESS') { + throw e; + } +} + +// eslint-disable-next-line no-extra-parens +var desc = !!hasProtoAccessor && gOPD && gOPD(Object.prototype, /** @type {keyof typeof Object.prototype} */ ('__proto__')); + +var $Object = Object; +var $getPrototypeOf = $Object.getPrototypeOf; + +/** @type {import('./get')} */ +module.exports = desc && typeof desc.get === 'function' + ? callBind([desc.get]) + : typeof $getPrototypeOf === 'function' + ? /** @type {import('./get')} */ function getDunder(value) { + // eslint-disable-next-line eqeqeq + return $getPrototypeOf(value == null ? value : $Object(value)); + } + : false; + + +/***/ }, + +/***/ 6649 +(module) { + +"use strict"; + + +/** @type {import('.')} */ +var $defineProperty = Object.defineProperty || false; +if ($defineProperty) { + try { + $defineProperty({}, 'a', { value: 1 }); + } catch (e) { + // IE 8 has a broken defineProperty + $defineProperty = false; + } +} + +module.exports = $defineProperty; + + +/***/ }, + +/***/ 9055 +(module) { + +"use strict"; + + +/** @type {import('./eval')} */ +module.exports = EvalError; + + +/***/ }, + +/***/ 5293 +(module) { + +"use strict"; + + +/** @type {import('.')} */ +module.exports = Error; + + +/***/ }, + +/***/ 8888 +(module) { + +"use strict"; + + +/** @type {import('./range')} */ +module.exports = RangeError; + + +/***/ }, + +/***/ 7900 +(module) { + +"use strict"; + + +/** @type {import('./ref')} */ +module.exports = ReferenceError; + + +/***/ }, + +/***/ 7770 +(module) { + +"use strict"; + + +/** @type {import('./syntax')} */ +module.exports = SyntaxError; + + +/***/ }, + +/***/ 6785 +(module) { + +"use strict"; + + +/** @type {import('./type')} */ +module.exports = TypeError; + + +/***/ }, + +/***/ 4055 +(module) { + +"use strict"; + + +/** @type {import('./uri')} */ +module.exports = URIError; + + +/***/ }, + +/***/ 5846 +(module) { + +"use strict"; + + +/** @type {import('.')} */ +module.exports = Object; + + +/***/ }, + +/***/ 4785 +(module) { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +var R = typeof Reflect === 'object' ? Reflect : null +var ReflectApply = R && typeof R.apply === 'function' + ? R.apply + : function ReflectApply(target, receiver, args) { + return Function.prototype.apply.call(target, receiver, args); + } + +var ReflectOwnKeys +if (R && typeof R.ownKeys === 'function') { + ReflectOwnKeys = R.ownKeys +} else if (Object.getOwnPropertySymbols) { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target) + .concat(Object.getOwnPropertySymbols(target)); + }; +} else { + ReflectOwnKeys = function ReflectOwnKeys(target) { + return Object.getOwnPropertyNames(target); + }; +} + +function ProcessEmitWarning(warning) { + if (console && console.warn) console.warn(warning); +} + +var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) { + return value !== value; +} + +function EventEmitter() { + EventEmitter.init.call(this); +} +module.exports = EventEmitter; +module.exports.once = once; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._eventsCount = 0; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +var defaultMaxListeners = 10; + +function checkListener(listener) { + if (typeof listener !== 'function') { + throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener); + } +} + +Object.defineProperty(EventEmitter, 'defaultMaxListeners', { + enumerable: true, + get: function() { + return defaultMaxListeners; + }, + set: function(arg) { + if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) { + throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.'); + } + defaultMaxListeners = arg; + } +}); + +EventEmitter.init = function() { + + if (this._events === undefined || + this._events === Object.getPrototypeOf(this)._events) { + this._events = Object.create(null); + this._eventsCount = 0; + } + + this._maxListeners = this._maxListeners || undefined; +}; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { + if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) { + throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.'); + } + this._maxListeners = n; + return this; +}; + +function _getMaxListeners(that) { + if (that._maxListeners === undefined) + return EventEmitter.defaultMaxListeners; + return that._maxListeners; +} + +EventEmitter.prototype.getMaxListeners = function getMaxListeners() { + return _getMaxListeners(this); +}; + +EventEmitter.prototype.emit = function emit(type) { + var args = []; + for (var i = 1; i < arguments.length; i++) args.push(arguments[i]); + var doError = (type === 'error'); + + var events = this._events; + if (events !== undefined) + doError = (doError && events.error === undefined); + else if (!doError) + return false; + + // If there is no 'error' event listener then throw. + if (doError) { + var er; + if (args.length > 0) + er = args[0]; + if (er instanceof Error) { + // Note: The comments on the `throw` lines are intentional, they show + // up in Node's output if this results in an unhandled exception. + throw er; // Unhandled 'error' event + } + // At least give some kind of context to the user + var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : '')); + err.context = er; + throw err; // Unhandled 'error' event + } + + var handler = events[type]; + + if (handler === undefined) + return false; + + if (typeof handler === 'function') { + ReflectApply(handler, this, args); + } else { + var len = handler.length; + var listeners = arrayClone(handler, len); + for (var i = 0; i < len; ++i) + ReflectApply(listeners[i], this, args); + } + + return true; +}; + +function _addListener(target, type, listener, prepend) { + var m; + var events; + var existing; + + checkListener(listener); + + events = target._events; + if (events === undefined) { + events = target._events = Object.create(null); + target._eventsCount = 0; + } else { + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (events.newListener !== undefined) { + target.emit('newListener', type, + listener.listener ? listener.listener : listener); + + // Re-assign `events` because a newListener handler could have caused the + // this._events to be assigned to a new object + events = target._events; + } + existing = events[type]; + } + + if (existing === undefined) { + // Optimize the case of one listener. Don't need the extra array object. + existing = events[type] = listener; + ++target._eventsCount; + } else { + if (typeof existing === 'function') { + // Adding the second element, need to change to array. + existing = events[type] = + prepend ? [listener, existing] : [existing, listener]; + // If we've already got an array, just append. + } else if (prepend) { + existing.unshift(listener); + } else { + existing.push(listener); + } + + // Check for listener leak + m = _getMaxListeners(target); + if (m > 0 && existing.length > m && !existing.warned) { + existing.warned = true; + // No error code for this since it is a Warning + // eslint-disable-next-line no-restricted-syntax + var w = new Error('Possible EventEmitter memory leak detected. ' + + existing.length + ' ' + String(type) + ' listeners ' + + 'added. Use emitter.setMaxListeners() to ' + + 'increase limit'); + w.name = 'MaxListenersExceededWarning'; + w.emitter = target; + w.type = type; + w.count = existing.length; + ProcessEmitWarning(w); + } + } + + return target; +} + +EventEmitter.prototype.addListener = function addListener(type, listener) { + return _addListener(this, type, listener, false); +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.prependListener = + function prependListener(type, listener) { + return _addListener(this, type, listener, true); + }; + +function onceWrapper() { + if (!this.fired) { + this.target.removeListener(this.type, this.wrapFn); + this.fired = true; + if (arguments.length === 0) + return this.listener.call(this.target); + return this.listener.apply(this.target, arguments); + } +} + +function _onceWrap(target, type, listener) { + var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener }; + var wrapped = onceWrapper.bind(state); + wrapped.listener = listener; + state.wrapFn = wrapped; + return wrapped; +} + +EventEmitter.prototype.once = function once(type, listener) { + checkListener(listener); + this.on(type, _onceWrap(this, type, listener)); + return this; +}; + +EventEmitter.prototype.prependOnceListener = + function prependOnceListener(type, listener) { + checkListener(listener); + this.prependListener(type, _onceWrap(this, type, listener)); + return this; + }; + +// Emits a 'removeListener' event if and only if the listener was removed. +EventEmitter.prototype.removeListener = + function removeListener(type, listener) { + var list, events, position, i, originalListener; + + checkListener(listener); + + events = this._events; + if (events === undefined) + return this; + + list = events[type]; + if (list === undefined) + return this; + + if (list === listener || list.listener === listener) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else { + delete events[type]; + if (events.removeListener) + this.emit('removeListener', type, list.listener || listener); + } + } else if (typeof list !== 'function') { + position = -1; + + for (i = list.length - 1; i >= 0; i--) { + if (list[i] === listener || list[i].listener === listener) { + originalListener = list[i].listener; + position = i; + break; + } + } + + if (position < 0) + return this; + + if (position === 0) + list.shift(); + else { + spliceOne(list, position); + } + + if (list.length === 1) + events[type] = list[0]; + + if (events.removeListener !== undefined) + this.emit('removeListener', type, originalListener || listener); + } + + return this; + }; + +EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + +EventEmitter.prototype.removeAllListeners = + function removeAllListeners(type) { + var listeners, events, i; + + events = this._events; + if (events === undefined) + return this; + + // not listening for removeListener, no need to emit + if (events.removeListener === undefined) { + if (arguments.length === 0) { + this._events = Object.create(null); + this._eventsCount = 0; + } else if (events[type] !== undefined) { + if (--this._eventsCount === 0) + this._events = Object.create(null); + else + delete events[type]; + } + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + var keys = Object.keys(events); + var key; + for (i = 0; i < keys.length; ++i) { + key = keys[i]; + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = Object.create(null); + this._eventsCount = 0; + return this; + } + + listeners = events[type]; + + if (typeof listeners === 'function') { + this.removeListener(type, listeners); + } else if (listeners !== undefined) { + // LIFO order + for (i = listeners.length - 1; i >= 0; i--) { + this.removeListener(type, listeners[i]); + } + } + + return this; + }; + +function _listeners(target, type, unwrap) { + var events = target._events; + + if (events === undefined) + return []; + + var evlistener = events[type]; + if (evlistener === undefined) + return []; + + if (typeof evlistener === 'function') + return unwrap ? [evlistener.listener || evlistener] : [evlistener]; + + return unwrap ? + unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length); +} + +EventEmitter.prototype.listeners = function listeners(type) { + return _listeners(this, type, true); +}; + +EventEmitter.prototype.rawListeners = function rawListeners(type) { + return _listeners(this, type, false); +}; + +EventEmitter.listenerCount = function(emitter, type) { + if (typeof emitter.listenerCount === 'function') { + return emitter.listenerCount(type); + } else { + return listenerCount.call(emitter, type); + } +}; + +EventEmitter.prototype.listenerCount = listenerCount; +function listenerCount(type) { + var events = this._events; + + if (events !== undefined) { + var evlistener = events[type]; + + if (typeof evlistener === 'function') { + return 1; + } else if (evlistener !== undefined) { + return evlistener.length; + } + } + + return 0; +} + +EventEmitter.prototype.eventNames = function eventNames() { + return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; +}; + +function arrayClone(arr, n) { + var copy = new Array(n); + for (var i = 0; i < n; ++i) + copy[i] = arr[i]; + return copy; +} + +function spliceOne(list, index) { + for (; index + 1 < list.length; index++) + list[index] = list[index + 1]; + list.pop(); +} + +function unwrapListeners(arr) { + var ret = new Array(arr.length); + for (var i = 0; i < ret.length; ++i) { + ret[i] = arr[i].listener || arr[i]; + } + return ret; +} + +function once(emitter, name) { + return new Promise(function (resolve, reject) { + function errorListener(err) { + emitter.removeListener(name, resolver); + reject(err); + } + + function resolver() { + if (typeof emitter.removeListener === 'function') { + emitter.removeListener('error', errorListener); + } + resolve([].slice.call(arguments)); + }; + + eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); + if (name !== 'error') { + addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true }); + } + }); +} + +function addErrorHandlerIfEventEmitter(emitter, handler, flags) { + if (typeof emitter.on === 'function') { + eventTargetAgnosticAddListener(emitter, 'error', handler, flags); + } +} + +function eventTargetAgnosticAddListener(emitter, name, listener, flags) { + if (typeof emitter.on === 'function') { + if (flags.once) { + emitter.once(name, listener); + } else { + emitter.on(name, listener); + } + } else if (typeof emitter.addEventListener === 'function') { + // EventTarget does not have `error` event semantics like Node + // EventEmitters, we do not listen for `error` events here. + emitter.addEventListener(name, function wrapListener(arg) { + // IE does not have builtin `{ once: true }` support so we + // have to do it manually. + if (flags.once) { + emitter.removeEventListener(name, wrapListener); + } + listener(arg); + }); + } else { + throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter); + } +} + + +/***/ }, + +/***/ 2022 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +// eslint-disable-next-line func-names +module.exports = function () { + if (typeof globalThis === "object") { + return globalThis; + } + var g; + try { + // This works if eval is allowed (see CSP) + // eslint-disable-next-line no-new-func + g = this || new Function("return this")(); + } catch (e) { + // This works if the window reference is available + if (typeof window === "object") { + return window; + } + + // This works if the self reference is available + if (typeof self === "object") { + return self; + } + + // This works if the global reference is available + if (typeof __webpack_require__.g !== "undefined") { + return __webpack_require__.g; + } + } + return g; +}(); + +/***/ }, + +/***/ 453 +(module) { + +"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; +}; + + +/***/ }, + +/***/ 8404 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var isCallable = __webpack_require__(3746); + +var toStr = Object.prototype.toString; +var hasOwnProperty = Object.prototype.hasOwnProperty; + +/** @type {(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */ +var forEachArray = function forEachArray(array, iterator, receiver) { + for (var i = 0, len = array.length; i < len; i++) { + if (hasOwnProperty.call(array, i)) { + if (receiver == null) { + iterator(array[i], i, array); + } else { + iterator.call(receiver, array[i], i, array); + } + } + } +}; + +/** @type {(string: S, iterator: (this: This | void, value: S[number], index: number, string: S) => void, receiver: This | undefined) => void} */ +var forEachString = function forEachString(string, iterator, receiver) { + for (var i = 0, len = string.length; i < len; i++) { + // no such thing as a sparse string. + if (receiver == null) { + iterator(string.charAt(i), i, string); + } else { + iterator.call(receiver, string.charAt(i), i, string); + } + } +}; + +/** @type {(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */ +var forEachObject = function forEachObject(object, iterator, receiver) { + for (var k in object) { + if (hasOwnProperty.call(object, k)) { + if (receiver == null) { + iterator(object[k], k, object); + } else { + iterator.call(receiver, object[k], k, object); + } + } + } +}; + +/** @type {(x: unknown) => x is readonly unknown[]} */ +function isArray(x) { + return toStr.call(x) === '[object Array]'; +} + +/** @type {import('.')._internal} */ +module.exports = function forEach(list, iterator, thisArg) { + if (!isCallable(iterator)) { + throw new TypeError('iterator must be a function'); + } + + var receiver; + if (arguments.length >= 3) { + receiver = thisArg; + } + + if (isArray(list)) { + forEachArray(list, iterator, receiver); + } else if (typeof list === 'string') { + forEachString(list, iterator, receiver); + } else { + forEachObject(list, iterator, receiver); + } +}; + + +/***/ }, + +/***/ 2719 +(module) { + +"use strict"; + + +/* eslint no-invalid-this: 1 */ + +var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; +var toStr = Object.prototype.toString; +var max = Math.max; +var funcType = '[object Function]'; + +var concatty = function concatty(a, b) { + var arr = []; + + for (var i = 0; i < a.length; i += 1) { + arr[i] = a[i]; + } + for (var j = 0; j < b.length; j += 1) { + arr[j + a.length] = b[j]; + } + + return arr; +}; + +var slicy = function slicy(arrLike, offset) { + var arr = []; + for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) { + arr[j] = arrLike[i]; + } + return arr; +}; + +var joiny = function (arr, joiner) { + var str = ''; + for (var i = 0; i < arr.length; i += 1) { + str += arr[i]; + if (i + 1 < arr.length) { + str += joiner; + } + } + return str; +}; + +module.exports = function bind(that) { + var target = this; + if (typeof target !== 'function' || toStr.apply(target) !== funcType) { + throw new TypeError(ERROR_MESSAGE + target); + } + var args = slicy(arguments, 1); + + var bound; + var binder = function () { + if (this instanceof bound) { + var result = target.apply( + this, + concatty(args, arguments) + ); + if (Object(result) === result) { + return result; + } + return this; + } + return target.apply( + that, + concatty(args, arguments) + ); + + }; + + var boundLength = max(0, target.length - args.length); + var boundArgs = []; + for (var i = 0; i < boundLength; i++) { + boundArgs[i] = '$' + i; + } + + bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder); + + if (target.prototype) { + var Empty = function Empty() {}; + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + Empty.prototype = null; + } + + return bound; +}; + + +/***/ }, + +/***/ 5049 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var implementation = __webpack_require__(2719); + +module.exports = Function.prototype.bind || implementation; + + +/***/ }, + +/***/ 3011 +(module) { + +"use strict"; + + +// eslint-disable-next-line no-extra-parens, no-empty-function +const cached = /** @type {GeneratorFunctionConstructor} */ (function* () {}.constructor); + +/** @type {import('.')} */ +module.exports = () => cached; + + + +/***/ }, + +/***/ 8651 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var undefined; + +var $Object = __webpack_require__(5846); + +var $Error = __webpack_require__(5293); +var $EvalError = __webpack_require__(9055); +var $RangeError = __webpack_require__(8888); +var $ReferenceError = __webpack_require__(7900); +var $SyntaxError = __webpack_require__(7770); +var $TypeError = __webpack_require__(6785); +var $URIError = __webpack_require__(4055); + +var abs = __webpack_require__(716); +var floor = __webpack_require__(7450); +var max = __webpack_require__(3774); +var min = __webpack_require__(7552); +var pow = __webpack_require__(5874); +var round = __webpack_require__(9292); +var sign = __webpack_require__(6071); + +var $Function = Function; + +// eslint-disable-next-line consistent-return +var getEvalledConstructor = function (expressionSyntax) { + try { + return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')(); + } catch (e) {} +}; + +var $gOPD = __webpack_require__(8109); +var $defineProperty = __webpack_require__(6649); + +var throwTypeError = function () { + throw new $TypeError(); +}; +var ThrowTypeError = $gOPD + ? (function () { + try { + // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties + arguments.callee; // IE 8 does not throw here + return throwTypeError; + } catch (calleeThrows) { + try { + // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '') + return $gOPD(arguments, 'callee').get; + } catch (gOPDthrows) { + return throwTypeError; + } + } + }()) + : throwTypeError; + +var hasSymbols = __webpack_require__(3257)(); + +var getProto = __webpack_require__(7106); +var $ObjectGPO = __webpack_require__(3766); +var $ReflectGPO = __webpack_require__(6822); + +var $apply = __webpack_require__(3036); +var $call = __webpack_require__(78); + +var needsEval = {}; + +var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array); + +var INTRINSICS = { + __proto__: null, + '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError, + '%Array%': Array, + '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, + '%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined, + '%AsyncFromSyncIteratorPrototype%': undefined, + '%AsyncFunction%': needsEval, + '%AsyncGenerator%': needsEval, + '%AsyncGeneratorFunction%': needsEval, + '%AsyncIteratorPrototype%': needsEval, + '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, + '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt, + '%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array, + '%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array, + '%Boolean%': Boolean, + '%DataView%': typeof DataView === 'undefined' ? undefined : DataView, + '%Date%': Date, + '%decodeURI%': decodeURI, + '%decodeURIComponent%': decodeURIComponent, + '%encodeURI%': encodeURI, + '%encodeURIComponent%': encodeURIComponent, + '%Error%': $Error, + '%eval%': eval, // eslint-disable-line no-eval + '%EvalError%': $EvalError, + '%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array, + '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, + '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, + '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry, + '%Function%': $Function, + '%GeneratorFunction%': needsEval, + '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, + '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, + '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, + '%isFinite%': isFinite, + '%isNaN%': isNaN, + '%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined, + '%JSON%': typeof JSON === 'object' ? JSON : undefined, + '%Map%': typeof Map === 'undefined' ? undefined : Map, + '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()), + '%Math%': Math, + '%Number%': Number, + '%Object%': $Object, + '%Object.getOwnPropertyDescriptor%': $gOPD, + '%parseFloat%': parseFloat, + '%parseInt%': parseInt, + '%Promise%': typeof Promise === 'undefined' ? undefined : Promise, + '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, + '%RangeError%': $RangeError, + '%ReferenceError%': $ReferenceError, + '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, + '%RegExp%': RegExp, + '%Set%': typeof Set === 'undefined' ? undefined : Set, + '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()), + '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, + '%String%': String, + '%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined, + '%Symbol%': hasSymbols ? Symbol : undefined, + '%SyntaxError%': $SyntaxError, + '%ThrowTypeError%': ThrowTypeError, + '%TypedArray%': TypedArray, + '%TypeError%': $TypeError, + '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, + '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, + '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, + '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, + '%URIError%': $URIError, + '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, + '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef, + '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet, + + '%Function.prototype.call%': $call, + '%Function.prototype.apply%': $apply, + '%Object.defineProperty%': $defineProperty, + '%Object.getPrototypeOf%': $ObjectGPO, + '%Math.abs%': abs, + '%Math.floor%': floor, + '%Math.max%': max, + '%Math.min%': min, + '%Math.pow%': pow, + '%Math.round%': round, + '%Math.sign%': sign, + '%Reflect.getPrototypeOf%': $ReflectGPO +}; + +if (getProto) { + try { + null.error; // eslint-disable-line no-unused-expressions + } catch (e) { + // https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229 + var errorProto = getProto(getProto(e)); + INTRINSICS['%Error.prototype%'] = errorProto; + } +} + +var doEval = function doEval(name) { + var value; + if (name === '%AsyncFunction%') { + value = getEvalledConstructor('async function () {}'); + } else if (name === '%GeneratorFunction%') { + value = getEvalledConstructor('function* () {}'); + } else if (name === '%AsyncGeneratorFunction%') { + value = getEvalledConstructor('async function* () {}'); + } else if (name === '%AsyncGenerator%') { + var fn = doEval('%AsyncGeneratorFunction%'); + if (fn) { + value = fn.prototype; + } + } else if (name === '%AsyncIteratorPrototype%') { + var gen = doEval('%AsyncGenerator%'); + if (gen && getProto) { + value = getProto(gen.prototype); + } + } + + INTRINSICS[name] = value; + + return value; +}; + +var LEGACY_ALIASES = { + __proto__: null, + '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'], + '%ArrayPrototype%': ['Array', 'prototype'], + '%ArrayProto_entries%': ['Array', 'prototype', 'entries'], + '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'], + '%ArrayProto_keys%': ['Array', 'prototype', 'keys'], + '%ArrayProto_values%': ['Array', 'prototype', 'values'], + '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'], + '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'], + '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'], + '%BooleanPrototype%': ['Boolean', 'prototype'], + '%DataViewPrototype%': ['DataView', 'prototype'], + '%DatePrototype%': ['Date', 'prototype'], + '%ErrorPrototype%': ['Error', 'prototype'], + '%EvalErrorPrototype%': ['EvalError', 'prototype'], + '%Float32ArrayPrototype%': ['Float32Array', 'prototype'], + '%Float64ArrayPrototype%': ['Float64Array', 'prototype'], + '%FunctionPrototype%': ['Function', 'prototype'], + '%Generator%': ['GeneratorFunction', 'prototype'], + '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'], + '%Int8ArrayPrototype%': ['Int8Array', 'prototype'], + '%Int16ArrayPrototype%': ['Int16Array', 'prototype'], + '%Int32ArrayPrototype%': ['Int32Array', 'prototype'], + '%JSONParse%': ['JSON', 'parse'], + '%JSONStringify%': ['JSON', 'stringify'], + '%MapPrototype%': ['Map', 'prototype'], + '%NumberPrototype%': ['Number', 'prototype'], + '%ObjectPrototype%': ['Object', 'prototype'], + '%ObjProto_toString%': ['Object', 'prototype', 'toString'], + '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'], + '%PromisePrototype%': ['Promise', 'prototype'], + '%PromiseProto_then%': ['Promise', 'prototype', 'then'], + '%Promise_all%': ['Promise', 'all'], + '%Promise_reject%': ['Promise', 'reject'], + '%Promise_resolve%': ['Promise', 'resolve'], + '%RangeErrorPrototype%': ['RangeError', 'prototype'], + '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'], + '%RegExpPrototype%': ['RegExp', 'prototype'], + '%SetPrototype%': ['Set', 'prototype'], + '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'], + '%StringPrototype%': ['String', 'prototype'], + '%SymbolPrototype%': ['Symbol', 'prototype'], + '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'], + '%TypedArrayPrototype%': ['TypedArray', 'prototype'], + '%TypeErrorPrototype%': ['TypeError', 'prototype'], + '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'], + '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'], + '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'], + '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'], + '%URIErrorPrototype%': ['URIError', 'prototype'], + '%WeakMapPrototype%': ['WeakMap', 'prototype'], + '%WeakSetPrototype%': ['WeakSet', 'prototype'] +}; + +var bind = __webpack_require__(5049); +var hasOwn = __webpack_require__(5215); +var $concat = bind.call($call, Array.prototype.concat); +var $spliceApply = bind.call($apply, Array.prototype.splice); +var $replace = bind.call($call, String.prototype.replace); +var $strSlice = bind.call($call, String.prototype.slice); +var $exec = bind.call($call, RegExp.prototype.exec); + +/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */ +var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; +var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */ +var stringToPath = function stringToPath(string) { + var first = $strSlice(string, 0, 1); + var last = $strSlice(string, -1); + if (first === '%' && last !== '%') { + throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`'); + } else if (last === '%' && first !== '%') { + throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`'); + } + var result = []; + $replace(string, rePropName, function (match, number, quote, subString) { + result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match; + }); + return result; +}; +/* end adaptation */ + +var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) { + var intrinsicName = name; + var alias; + if (hasOwn(LEGACY_ALIASES, intrinsicName)) { + alias = LEGACY_ALIASES[intrinsicName]; + intrinsicName = '%' + alias[0] + '%'; + } + + if (hasOwn(INTRINSICS, intrinsicName)) { + var value = INTRINSICS[intrinsicName]; + if (value === needsEval) { + value = doEval(intrinsicName); + } + if (typeof value === 'undefined' && !allowMissing) { + throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); + } + + return { + alias: alias, + name: intrinsicName, + value: value + }; + } + + throw new $SyntaxError('intrinsic ' + name + ' does not exist!'); +}; + +module.exports = function GetIntrinsic(name, allowMissing) { + if (typeof name !== 'string' || name.length === 0) { + throw new $TypeError('intrinsic name must be a non-empty string'); + } + if (arguments.length > 1 && typeof allowMissing !== 'boolean') { + throw new $TypeError('"allowMissing" argument must be a boolean'); + } + + if ($exec(/^%?[^%]*%?$/, name) === null) { + throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name'); + } + var parts = stringToPath(name); + var intrinsicBaseName = parts.length > 0 ? parts[0] : ''; + + var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing); + var intrinsicRealName = intrinsic.name; + var value = intrinsic.value; + var skipFurtherCaching = false; + + var alias = intrinsic.alias; + if (alias) { + intrinsicBaseName = alias[0]; + $spliceApply(parts, $concat([0, 1], alias)); + } + + for (var i = 1, isOwn = true; i < parts.length; i += 1) { + var part = parts[i]; + var first = $strSlice(part, 0, 1); + var last = $strSlice(part, -1); + if ( + ( + (first === '"' || first === "'" || first === '`') + || (last === '"' || last === "'" || last === '`') + ) + && first !== last + ) { + throw new $SyntaxError('property names with quotes must have matching quotes'); + } + if (part === 'constructor' || !isOwn) { + skipFurtherCaching = true; + } + + intrinsicBaseName += '.' + part; + intrinsicRealName = '%' + intrinsicBaseName + '%'; + + if (hasOwn(INTRINSICS, intrinsicRealName)) { + value = INTRINSICS[intrinsicRealName]; + } else if (value != null) { + if (!(part in value)) { + if (!allowMissing) { + throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.'); + } + return void undefined; + } + if ($gOPD && (i + 1) >= parts.length) { + var desc = $gOPD(value, part); + isOwn = !!desc; + + // By convention, when a data property is converted to an accessor + // property to emulate a data property that does not suffer from + // the override mistake, that accessor's getter is marked with + // an `originalValue` property. Here, when we detect this, we + // uphold the illusion by pretending to see that original data + // property, i.e., returning the value rather than the getter + // itself. + if (isOwn && 'get' in desc && !('originalValue' in desc.get)) { + value = desc.get; + } else { + value = value[part]; + } + } else { + isOwn = hasOwn(value, part); + value = value[part]; + } + + if (isOwn && !skipFurtherCaching) { + INTRINSICS[intrinsicRealName] = value; + } + } + } + return value; +}; + + +/***/ }, + +/***/ 3766 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var $Object = __webpack_require__(5846); + +/** @type {import('./Object.getPrototypeOf')} */ +module.exports = $Object.getPrototypeOf || null; + + +/***/ }, + +/***/ 6822 +(module) { + +"use strict"; + + +/** @type {import('./Reflect.getPrototypeOf')} */ +module.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null; + + +/***/ }, + +/***/ 7106 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var reflectGetProto = __webpack_require__(6822); +var originalGetProto = __webpack_require__(3766); + +var getDunderProto = __webpack_require__(9302); + +/** @type {import('.')} */ +module.exports = reflectGetProto + ? function getProto(O) { + // @ts-expect-error TS can't narrow inside a closure, for some reason + return reflectGetProto(O); + } + : originalGetProto + ? function getProto(O) { + if (!O || (typeof O !== 'object' && typeof O !== 'function')) { + throw new TypeError('getProto: not an object'); + } + // @ts-expect-error TS can't narrow inside a closure, for some reason + return originalGetProto(O); + } + : getDunderProto + ? function getProto(O) { + // @ts-expect-error TS can't narrow inside a closure, for some reason + return getDunderProto(O); + } + : null; + + +/***/ }, + +/***/ 5567 +(module) { + +"use strict"; + + +/** @type {import('./gOPD')} */ +module.exports = Object.getOwnPropertyDescriptor; + + +/***/ }, + +/***/ 8109 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +/** @type {import('.')} */ +var $gOPD = __webpack_require__(5567); + +if ($gOPD) { + try { + $gOPD([], 'length'); + } catch (e) { + // IE 8 has a broken gOPD + $gOPD = null; + } +} + +module.exports = $gOPD; + + +/***/ }, + +/***/ 8890 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var $defineProperty = __webpack_require__(6649); + +var hasPropertyDescriptors = function hasPropertyDescriptors() { + return !!$defineProperty; +}; + +hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() { + // node v0.6 has a bug where array lengths can be Set but not Defined + if (!$defineProperty) { + return null; + } + try { + return $defineProperty([], 'length', { value: 1 }).length !== 1; + } catch (e) { + // In Firefox 4-22, defining length on an array throws an exception. + return true; + } +}; + +module.exports = hasPropertyDescriptors; + + +/***/ }, + +/***/ 3257 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var origSymbol = typeof Symbol !== 'undefined' && Symbol; +var hasSymbolSham = __webpack_require__(2843); + +/** @type {import('.')} */ +module.exports = function hasNativeSymbols() { + if (typeof origSymbol !== 'function') { return false; } + if (typeof Symbol !== 'function') { return false; } + if (typeof origSymbol('foo') !== 'symbol') { return false; } + if (typeof Symbol('bar') !== 'symbol') { return false; } + + return hasSymbolSham(); +}; + + +/***/ }, + +/***/ 2843 +(module) { + +"use strict"; + + +/** @type {import('./shams')} */ +/* eslint complexity: [2, 18], max-statements: [2, 33] */ +module.exports = function hasSymbols() { + if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; } + if (typeof Symbol.iterator === 'symbol') { return true; } + + /** @type {{ [k in symbol]?: unknown }} */ + var obj = {}; + var sym = Symbol('test'); + var symObj = Object(sym); + if (typeof sym === 'string') { return false; } + + if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; } + if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; } + + // temp disabled per https://github.com/ljharb/object.assign/issues/17 + // if (sym instanceof Symbol) { return false; } + // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4 + // if (!(symObj instanceof Symbol)) { return false; } + + // if (typeof Symbol.prototype.toString !== 'function') { return false; } + // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; } + + var symVal = 42; + obj[sym] = symVal; + for (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop + if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; } + + if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; } + + var syms = Object.getOwnPropertySymbols(obj); + if (syms.length !== 1 || syms[0] !== sym) { return false; } + + if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; } + + if (typeof Object.getOwnPropertyDescriptor === 'function') { + // eslint-disable-next-line no-extra-parens + var descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym)); + if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; } + } + + return true; +}; + + +/***/ }, + +/***/ 6626 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var hasSymbols = __webpack_require__(2843); + +/** @type {import('.')} */ +module.exports = function hasToStringTagShams() { + return hasSymbols() && !!Symbol.toStringTag; +}; + + +/***/ }, + +/***/ 5215 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var call = Function.prototype.call; +var $hasOwn = Object.prototype.hasOwnProperty; +var bind = __webpack_require__(5049); + +/** @type {import('.')} */ +module.exports = bind.call(call, $hasOwn); + + +/***/ }, + +/***/ 9029 +(__unused_webpack_module, exports) { + +/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh */ +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 +} + + +/***/ }, + +/***/ 9784 +(module) { + +if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }) + } + }; +} else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } + } +} + + +/***/ }, + +/***/ 7906 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var hasToStringTag = __webpack_require__(6626)(); +var callBound = __webpack_require__(2774); + +var $toString = callBound('Object.prototype.toString'); + +/** @type {import('.')} */ +var isStandardArguments = function isArguments(value) { + if ( + hasToStringTag + && value + && typeof value === 'object' + && Symbol.toStringTag in value + ) { + return false; + } + return $toString(value) === '[object Arguments]'; +}; + +/** @type {import('.')} */ +var isLegacyArguments = function isArguments(value) { + if (isStandardArguments(value)) { + return true; + } + return value !== null + && typeof value === 'object' + && 'length' in value + && typeof value.length === 'number' + && value.length >= 0 + && $toString(value) !== '[object Array]' + && 'callee' in value + && $toString(value.callee) === '[object Function]'; +}; + +var supportsStandardArguments = (function () { + return isStandardArguments(arguments); +}()); + +// @ts-expect-error TODO make this not error +isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests + +/** @type {import('.')} */ +module.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments; + + +/***/ }, + +/***/ 3746 +(module) { + +"use strict"; + + +var fnToStr = Function.prototype.toString; +var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply; +var badArrayLike; +var isCallableMarker; +if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') { + try { + badArrayLike = Object.defineProperty({}, 'length', { + get: function () { + throw isCallableMarker; + } + }); + isCallableMarker = {}; + // eslint-disable-next-line no-throw-literal + reflectApply(function () { throw 42; }, null, badArrayLike); + } catch (_) { + if (_ !== isCallableMarker) { + reflectApply = null; + } + } +} else { + reflectApply = null; +} + +var constructorRegex = /^\s*class\b/; +var isES6ClassFn = function isES6ClassFunction(value) { + try { + var fnStr = fnToStr.call(value); + return constructorRegex.test(fnStr); + } catch (e) { + return false; // not a function + } +}; + +var tryFunctionObject = function tryFunctionToStr(value) { + try { + if (isES6ClassFn(value)) { return false; } + fnToStr.call(value); + return true; + } catch (e) { + return false; + } +}; +var toStr = Object.prototype.toString; +var objectClass = '[object Object]'; +var fnClass = '[object Function]'; +var genClass = '[object GeneratorFunction]'; +var ddaClass = '[object HTMLAllCollection]'; // IE 11 +var ddaClass2 = '[object HTML document.all class]'; +var ddaClass3 = '[object HTMLCollection]'; // IE 9-10 +var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag` + +var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing + +var isDDA = function isDocumentDotAll() { return false; }; +if (typeof document === 'object') { + // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly + var all = document.all; + if (toStr.call(all) === toStr.call(document.all)) { + isDDA = function isDocumentDotAll(value) { + /* globals document: false */ + // in IE 6-8, typeof document.all is "object" and it's truthy + if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) { + try { + var str = toStr.call(value); + return ( + str === ddaClass + || str === ddaClass2 + || str === ddaClass3 // opera 12.16 + || str === objectClass // IE 6-8 + ) && value('') == null; // eslint-disable-line eqeqeq + } catch (e) { /**/ } + } + return false; + }; + } +} + +module.exports = reflectApply + ? function isCallable(value) { + if (isDDA(value)) { return true; } + if (!value) { return false; } + if (typeof value !== 'function' && typeof value !== 'object') { return false; } + try { + reflectApply(value, null, badArrayLike); + } catch (e) { + if (e !== isCallableMarker) { return false; } + } + return !isES6ClassFn(value) && tryFunctionObject(value); + } + : function isCallable(value) { + if (isDDA(value)) { return true; } + if (!value) { return false; } + if (typeof value !== 'function' && typeof value !== 'object') { return false; } + if (hasToStringTag) { return tryFunctionObject(value); } + if (isES6ClassFn(value)) { return false; } + var strClass = toStr.call(value); + if (strClass !== fnClass && strClass !== genClass && !(/^\[object HTML/).test(strClass)) { return false; } + return tryFunctionObject(value); + }; + + +/***/ }, + +/***/ 4610 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var callBound = __webpack_require__(2774); +var safeRegexTest = __webpack_require__(8843); +var isFnRegex = safeRegexTest(/^\s*(?:function)?\*/); +var hasToStringTag = __webpack_require__(6626)(); +var getProto = __webpack_require__(7106); + +var toStr = callBound('Object.prototype.toString'); +var fnToStr = callBound('Function.prototype.toString'); + +var getGeneratorFunction = __webpack_require__(3011); + +/** @type {import('.')} */ +module.exports = function isGeneratorFunction(fn) { + if (typeof fn !== 'function') { + return false; + } + if (isFnRegex(fnToStr(fn))) { + return true; + } + if (!hasToStringTag) { + var str = toStr(fn); + return str === '[object GeneratorFunction]'; + } + if (!getProto) { + return false; + } + var GeneratorFunction = getGeneratorFunction(); + return GeneratorFunction && getProto(fn) === GeneratorFunction.prototype; +}; + + +/***/ }, + +/***/ 2621 +(module) { + +"use strict"; + + +/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */ + +module.exports = function isNaN(value) { + return value !== value; +}; + + +/***/ }, + +/***/ 7051 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var callBind = __webpack_require__(6601); +var define = __webpack_require__(5421); + +var implementation = __webpack_require__(2621); +var getPolyfill = __webpack_require__(1320); +var shim = __webpack_require__(5074); + +var polyfill = callBind(getPolyfill(), Number); + +/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */ + +define(polyfill, { + getPolyfill: getPolyfill, + implementation: implementation, + shim: shim +}); + +module.exports = polyfill; + + +/***/ }, + +/***/ 1320 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var implementation = __webpack_require__(2621); + +module.exports = function getPolyfill() { + if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN('a')) { + return Number.isNaN; + } + return implementation; +}; + + +/***/ }, + +/***/ 5074 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var define = __webpack_require__(5421); +var getPolyfill = __webpack_require__(1320); + +/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */ + +module.exports = function shimNumberIsNaN() { + var polyfill = getPolyfill(); + define(Number, { isNaN: polyfill }, { + isNaN: function testIsNaN() { + return Number.isNaN !== polyfill; + } + }); + return polyfill; +}; + + +/***/ }, + +/***/ 1689 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var callBound = __webpack_require__(2774); +var hasToStringTag = __webpack_require__(6626)(); +var hasOwn = __webpack_require__(5215); +var gOPD = __webpack_require__(8109); + +/** @type {import('.')} */ +var fn; + +if (hasToStringTag) { + /** @type {(receiver: ThisParameterType, ...args: Parameters) => ReturnType} */ + var $exec = callBound('RegExp.prototype.exec'); + /** @type {object} */ + var isRegexMarker = {}; + + var throwRegexMarker = function () { + throw isRegexMarker; + }; + /** @type {{ toString(): never, valueOf(): never, [Symbol.toPrimitive]?(): never }} */ + var badStringifier = { + toString: throwRegexMarker, + valueOf: throwRegexMarker + }; + + if (typeof Symbol.toPrimitive === 'symbol') { + badStringifier[Symbol.toPrimitive] = throwRegexMarker; + } + + /** @type {import('.')} */ + // @ts-expect-error TS can't figure out that the $exec call always throws + // eslint-disable-next-line consistent-return + fn = function isRegex(value) { + if (!value || typeof value !== 'object') { + return false; + } + + // eslint-disable-next-line no-extra-parens + var descriptor = /** @type {NonNullable} */ (gOPD)(/** @type {{ lastIndex?: unknown }} */ (value), 'lastIndex'); + var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, 'value'); + if (!hasLastIndexDataProperty) { + return false; + } + + try { + // eslint-disable-next-line no-extra-parens + $exec(value, /** @type {string} */ (/** @type {unknown} */ (badStringifier))); + } catch (e) { + return e === isRegexMarker; + } + }; +} else { + /** @type {(receiver: ThisParameterType, ...args: Parameters) => ReturnType} */ + var $toString = callBound('Object.prototype.toString'); + /** @const @type {'[object RegExp]'} */ + var regexClass = '[object RegExp]'; + + /** @type {import('.')} */ + fn = function isRegex(value) { + // In older browsers, typeof regex incorrectly returns 'function' + if (!value || (typeof value !== 'object' && typeof value !== 'function')) { + return false; + } + + return $toString(value) === regexClass; + }; +} + +module.exports = fn; + + +/***/ }, + +/***/ 6094 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var whichTypedArray = __webpack_require__(3381); + +/** @type {import('.')} */ +module.exports = function isTypedArray(value) { + return !!whichTypedArray(value); +}; + + +/***/ }, + +/***/ 1632 +(module, exports, __webpack_require__) { + +/* provided dependency */ var process = __webpack_require__(9964); +var __WEBPACK_AMD_DEFINE_RESULT__;/** + * [js-md5]{@link https://github.com/emn178/js-md5} + * + * @namespace md5 + * @version 0.8.3 + * @author Chen, Yi-Cyuan [emn178@gmail.com] + * @copyright Chen, Yi-Cyuan 2014-2023 + * @license MIT + */ +(function () { + 'use strict'; + + var INPUT_ERROR = 'input is invalid type'; + var FINALIZE_ERROR = 'finalize already called'; + var WINDOW = typeof window === 'object'; + var root = WINDOW ? window : {}; + if (root.JS_MD5_NO_WINDOW) { + WINDOW = false; + } + var WEB_WORKER = !WINDOW && typeof self === 'object'; + var NODE_JS = !root.JS_MD5_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node; + if (NODE_JS) { + root = __webpack_require__.g; + } else if (WEB_WORKER) { + root = self; + } + var COMMON_JS = !root.JS_MD5_NO_COMMON_JS && "object" === 'object' && module.exports; + var AMD = true && __webpack_require__.amdO; + var ARRAY_BUFFER = !root.JS_MD5_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined'; + var HEX_CHARS = '0123456789abcdef'.split(''); + var EXTRA = [128, 32768, 8388608, -2147483648]; + var SHIFT = [0, 8, 16, 24]; + var OUTPUT_TYPES = ['hex', 'array', 'digest', 'buffer', 'arrayBuffer', 'base64']; + var BASE64_ENCODE_CHAR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split(''); + + var blocks = [], buffer8; + if (ARRAY_BUFFER) { + var buffer = new ArrayBuffer(68); + buffer8 = new Uint8Array(buffer); + blocks = new Uint32Array(buffer); + } + + var isArray = Array.isArray; + if (root.JS_MD5_NO_NODE_JS || !isArray) { + isArray = function (obj) { + return Object.prototype.toString.call(obj) === '[object Array]'; + }; + } + + var isView = ArrayBuffer.isView; + if (ARRAY_BUFFER && (root.JS_MD5_NO_ARRAY_BUFFER_IS_VIEW || !isView)) { + isView = function (obj) { + return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer; + }; + } + + // [message: string, isString: bool] + var formatMessage = function (message) { + var type = typeof message; + if (type === 'string') { + return [message, true]; + } + if (type !== 'object' || message === null) { + throw new Error(INPUT_ERROR); + } + if (ARRAY_BUFFER && message.constructor === ArrayBuffer) { + return [new Uint8Array(message), false]; + } + if (!isArray(message) && !isView(message)) { + throw new Error(INPUT_ERROR); + } + return [message, false]; + } + + /** + * @method hex + * @memberof md5 + * @description Output hash as hex string + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {String} Hex string + * @example + * md5.hex('The quick brown fox jumps over the lazy dog'); + * // equal to + * md5('The quick brown fox jumps over the lazy dog'); + */ + /** + * @method digest + * @memberof md5 + * @description Output hash as bytes array + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {Array} Bytes array + * @example + * md5.digest('The quick brown fox jumps over the lazy dog'); + */ + /** + * @method array + * @memberof md5 + * @description Output hash as bytes array + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {Array} Bytes array + * @example + * md5.array('The quick brown fox jumps over the lazy dog'); + */ + /** + * @method arrayBuffer + * @memberof md5 + * @description Output hash as ArrayBuffer + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {ArrayBuffer} ArrayBuffer + * @example + * md5.arrayBuffer('The quick brown fox jumps over the lazy dog'); + */ + /** + * @method buffer + * @deprecated This maybe confuse with Buffer in node.js. Please use arrayBuffer instead. + * @memberof md5 + * @description Output hash as ArrayBuffer + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {ArrayBuffer} ArrayBuffer + * @example + * md5.buffer('The quick brown fox jumps over the lazy dog'); + */ + /** + * @method base64 + * @memberof md5 + * @description Output hash as base64 string + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {String} base64 string + * @example + * md5.base64('The quick brown fox jumps over the lazy dog'); + */ + var createOutputMethod = function (outputType) { + return function (message) { + return new Md5(true).update(message)[outputType](); + }; + }; + + /** + * @method create + * @memberof md5 + * @description Create Md5 object + * @returns {Md5} Md5 object. + * @example + * var hash = md5.create(); + */ + /** + * @method update + * @memberof md5 + * @description Create and update Md5 object + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {Md5} Md5 object. + * @example + * var hash = md5.update('The quick brown fox jumps over the lazy dog'); + * // equal to + * var hash = md5.create(); + * hash.update('The quick brown fox jumps over the lazy dog'); + */ + var createMethod = function () { + var method = createOutputMethod('hex'); + if (NODE_JS) { + method = nodeWrap(method); + } + method.create = function () { + return new Md5(); + }; + method.update = function (message) { + return method.create().update(message); + }; + for (var i = 0; i < OUTPUT_TYPES.length; ++i) { + var type = OUTPUT_TYPES[i]; + method[type] = createOutputMethod(type); + } + return method; + }; + + var nodeWrap = function (method) { + var crypto = __webpack_require__(8535) + var Buffer = (__webpack_require__(6274).Buffer); + var bufferFrom; + if (Buffer.from && !root.JS_MD5_NO_BUFFER_FROM) { + bufferFrom = Buffer.from; + } else { + bufferFrom = function (message) { + return new Buffer(message); + }; + } + var nodeMethod = function (message) { + if (typeof message === 'string') { + return crypto.createHash('md5').update(message, 'utf8').digest('hex'); + } else { + if (message === null || message === undefined) { + throw new Error(INPUT_ERROR); + } else if (message.constructor === ArrayBuffer) { + message = new Uint8Array(message); + } + } + if (isArray(message) || isView(message) || + message.constructor === Buffer) { + return crypto.createHash('md5').update(bufferFrom(message)).digest('hex'); + } else { + return method(message); + } + }; + return nodeMethod; + }; + + /** + * @namespace md5.hmac + */ + /** + * @method hex + * @memberof md5.hmac + * @description Output hash as hex string + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {String} Hex string + * @example + * md5.hmac.hex('key', 'The quick brown fox jumps over the lazy dog'); + * // equal to + * md5.hmac('key', 'The quick brown fox jumps over the lazy dog'); + */ + + /** + * @method digest + * @memberof md5.hmac + * @description Output hash as bytes array + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {Array} Bytes array + * @example + * md5.hmac.digest('key', 'The quick brown fox jumps over the lazy dog'); + */ + /** + * @method array + * @memberof md5.hmac + * @description Output hash as bytes array + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {Array} Bytes array + * @example + * md5.hmac.array('key', 'The quick brown fox jumps over the lazy dog'); + */ + /** + * @method arrayBuffer + * @memberof md5.hmac + * @description Output hash as ArrayBuffer + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {ArrayBuffer} ArrayBuffer + * @example + * md5.hmac.arrayBuffer('key', 'The quick brown fox jumps over the lazy dog'); + */ + /** + * @method buffer + * @deprecated This maybe confuse with Buffer in node.js. Please use arrayBuffer instead. + * @memberof md5.hmac + * @description Output hash as ArrayBuffer + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {ArrayBuffer} ArrayBuffer + * @example + * md5.hmac.buffer('key', 'The quick brown fox jumps over the lazy dog'); + */ + /** + * @method base64 + * @memberof md5.hmac + * @description Output hash as base64 string + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {String} base64 string + * @example + * md5.hmac.base64('key', 'The quick brown fox jumps over the lazy dog'); + */ + var createHmacOutputMethod = function (outputType) { + return function (key, message) { + return new HmacMd5(key, true).update(message)[outputType](); + }; + }; + + /** + * @method create + * @memberof md5.hmac + * @description Create HmacMd5 object + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @returns {HmacMd5} HmacMd5 object. + * @example + * var hash = md5.hmac.create('key'); + */ + /** + * @method update + * @memberof md5.hmac + * @description Create and update HmacMd5 object + * @param {String|Array|Uint8Array|ArrayBuffer} key key + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {HmacMd5} HmacMd5 object. + * @example + * var hash = md5.hmac.update('key', 'The quick brown fox jumps over the lazy dog'); + * // equal to + * var hash = md5.hmac.create('key'); + * hash.update('The quick brown fox jumps over the lazy dog'); + */ + var createHmacMethod = function () { + var method = createHmacOutputMethod('hex'); + method.create = function (key) { + return new HmacMd5(key); + }; + method.update = function (key, message) { + return method.create(key).update(message); + }; + for (var i = 0; i < OUTPUT_TYPES.length; ++i) { + var type = OUTPUT_TYPES[i]; + method[type] = createHmacOutputMethod(type); + } + return method; + }; + + /** + * Md5 class + * @class Md5 + * @description This is internal class. + * @see {@link md5.create} + */ + function Md5(sharedMemory) { + if (sharedMemory) { + blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] = + blocks[4] = blocks[5] = blocks[6] = blocks[7] = + blocks[8] = blocks[9] = blocks[10] = blocks[11] = + blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0; + this.blocks = blocks; + this.buffer8 = buffer8; + } else { + if (ARRAY_BUFFER) { + var buffer = new ArrayBuffer(68); + this.buffer8 = new Uint8Array(buffer); + this.blocks = new Uint32Array(buffer); + } else { + this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + } + } + this.h0 = this.h1 = this.h2 = this.h3 = this.start = this.bytes = this.hBytes = 0; + this.finalized = this.hashed = false; + this.first = true; + } + + /** + * @method update + * @memberof Md5 + * @instance + * @description Update hash + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {Md5} Md5 object. + * @see {@link md5.update} + */ + Md5.prototype.update = function (message) { + if (this.finalized) { + throw new Error(FINALIZE_ERROR); + } + + var result = formatMessage(message); + message = result[0]; + var isString = result[1]; + var code, index = 0, i, length = message.length, blocks = this.blocks; + var buffer8 = this.buffer8; + + while (index < length) { + if (this.hashed) { + this.hashed = false; + blocks[0] = blocks[16]; + blocks[16] = blocks[1] = blocks[2] = blocks[3] = + blocks[4] = blocks[5] = blocks[6] = blocks[7] = + blocks[8] = blocks[9] = blocks[10] = blocks[11] = + blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0; + } + + if (isString) { + if (ARRAY_BUFFER) { + for (i = this.start; index < length && i < 64; ++index) { + code = message.charCodeAt(index); + if (code < 0x80) { + buffer8[i++] = code; + } else if (code < 0x800) { + buffer8[i++] = 0xc0 | (code >>> 6); + buffer8[i++] = 0x80 | (code & 0x3f); + } else if (code < 0xd800 || code >= 0xe000) { + buffer8[i++] = 0xe0 | (code >>> 12); + buffer8[i++] = 0x80 | ((code >>> 6) & 0x3f); + buffer8[i++] = 0x80 | (code & 0x3f); + } else { + code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff)); + buffer8[i++] = 0xf0 | (code >>> 18); + buffer8[i++] = 0x80 | ((code >>> 12) & 0x3f); + buffer8[i++] = 0x80 | ((code >>> 6) & 0x3f); + buffer8[i++] = 0x80 | (code & 0x3f); + } + } + } else { + for (i = this.start; index < length && i < 64; ++index) { + code = message.charCodeAt(index); + if (code < 0x80) { + blocks[i >>> 2] |= code << SHIFT[i++ & 3]; + } else if (code < 0x800) { + blocks[i >>> 2] |= (0xc0 | (code >>> 6)) << SHIFT[i++ & 3]; + blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3]; + } else if (code < 0xd800 || code >= 0xe000) { + blocks[i >>> 2] |= (0xe0 | (code >>> 12)) << SHIFT[i++ & 3]; + blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3]; + blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3]; + } else { + code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff)); + blocks[i >>> 2] |= (0xf0 | (code >>> 18)) << SHIFT[i++ & 3]; + blocks[i >>> 2] |= (0x80 | ((code >>> 12) & 0x3f)) << SHIFT[i++ & 3]; + blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3]; + blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3]; + } + } + } + } else { + if (ARRAY_BUFFER) { + for (i = this.start; index < length && i < 64; ++index) { + buffer8[i++] = message[index]; + } + } else { + for (i = this.start; index < length && i < 64; ++index) { + blocks[i >>> 2] |= message[index] << SHIFT[i++ & 3]; + } + } + } + this.lastByteIndex = i; + this.bytes += i - this.start; + if (i >= 64) { + this.start = i - 64; + this.hash(); + this.hashed = true; + } else { + this.start = i; + } + } + if (this.bytes > 4294967295) { + this.hBytes += this.bytes / 4294967296 << 0; + this.bytes = this.bytes % 4294967296; + } + return this; + }; + + Md5.prototype.finalize = function () { + if (this.finalized) { + return; + } + this.finalized = true; + var blocks = this.blocks, i = this.lastByteIndex; + blocks[i >>> 2] |= EXTRA[i & 3]; + if (i >= 56) { + if (!this.hashed) { + this.hash(); + } + blocks[0] = blocks[16]; + blocks[16] = blocks[1] = blocks[2] = blocks[3] = + blocks[4] = blocks[5] = blocks[6] = blocks[7] = + blocks[8] = blocks[9] = blocks[10] = blocks[11] = + blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0; + } + blocks[14] = this.bytes << 3; + blocks[15] = this.hBytes << 3 | this.bytes >>> 29; + this.hash(); + }; + + Md5.prototype.hash = function () { + var a, b, c, d, bc, da, blocks = this.blocks; + + if (this.first) { + a = blocks[0] - 680876937; + a = (a << 7 | a >>> 25) - 271733879 << 0; + d = (-1732584194 ^ a & 2004318071) + blocks[1] - 117830708; + d = (d << 12 | d >>> 20) + a << 0; + c = (-271733879 ^ (d & (a ^ -271733879))) + blocks[2] - 1126478375; + c = (c << 17 | c >>> 15) + d << 0; + b = (a ^ (c & (d ^ a))) + blocks[3] - 1316259209; + b = (b << 22 | b >>> 10) + c << 0; + } else { + a = this.h0; + b = this.h1; + c = this.h2; + d = this.h3; + a += (d ^ (b & (c ^ d))) + blocks[0] - 680876936; + a = (a << 7 | a >>> 25) + b << 0; + d += (c ^ (a & (b ^ c))) + blocks[1] - 389564586; + d = (d << 12 | d >>> 20) + a << 0; + c += (b ^ (d & (a ^ b))) + blocks[2] + 606105819; + c = (c << 17 | c >>> 15) + d << 0; + b += (a ^ (c & (d ^ a))) + blocks[3] - 1044525330; + b = (b << 22 | b >>> 10) + c << 0; + } + + a += (d ^ (b & (c ^ d))) + blocks[4] - 176418897; + a = (a << 7 | a >>> 25) + b << 0; + d += (c ^ (a & (b ^ c))) + blocks[5] + 1200080426; + d = (d << 12 | d >>> 20) + a << 0; + c += (b ^ (d & (a ^ b))) + blocks[6] - 1473231341; + c = (c << 17 | c >>> 15) + d << 0; + b += (a ^ (c & (d ^ a))) + blocks[7] - 45705983; + b = (b << 22 | b >>> 10) + c << 0; + a += (d ^ (b & (c ^ d))) + blocks[8] + 1770035416; + a = (a << 7 | a >>> 25) + b << 0; + d += (c ^ (a & (b ^ c))) + blocks[9] - 1958414417; + d = (d << 12 | d >>> 20) + a << 0; + c += (b ^ (d & (a ^ b))) + blocks[10] - 42063; + c = (c << 17 | c >>> 15) + d << 0; + b += (a ^ (c & (d ^ a))) + blocks[11] - 1990404162; + b = (b << 22 | b >>> 10) + c << 0; + a += (d ^ (b & (c ^ d))) + blocks[12] + 1804603682; + a = (a << 7 | a >>> 25) + b << 0; + d += (c ^ (a & (b ^ c))) + blocks[13] - 40341101; + d = (d << 12 | d >>> 20) + a << 0; + c += (b ^ (d & (a ^ b))) + blocks[14] - 1502002290; + c = (c << 17 | c >>> 15) + d << 0; + b += (a ^ (c & (d ^ a))) + blocks[15] + 1236535329; + b = (b << 22 | b >>> 10) + c << 0; + a += (c ^ (d & (b ^ c))) + blocks[1] - 165796510; + a = (a << 5 | a >>> 27) + b << 0; + d += (b ^ (c & (a ^ b))) + blocks[6] - 1069501632; + d = (d << 9 | d >>> 23) + a << 0; + c += (a ^ (b & (d ^ a))) + blocks[11] + 643717713; + c = (c << 14 | c >>> 18) + d << 0; + b += (d ^ (a & (c ^ d))) + blocks[0] - 373897302; + b = (b << 20 | b >>> 12) + c << 0; + a += (c ^ (d & (b ^ c))) + blocks[5] - 701558691; + a = (a << 5 | a >>> 27) + b << 0; + d += (b ^ (c & (a ^ b))) + blocks[10] + 38016083; + d = (d << 9 | d >>> 23) + a << 0; + c += (a ^ (b & (d ^ a))) + blocks[15] - 660478335; + c = (c << 14 | c >>> 18) + d << 0; + b += (d ^ (a & (c ^ d))) + blocks[4] - 405537848; + b = (b << 20 | b >>> 12) + c << 0; + a += (c ^ (d & (b ^ c))) + blocks[9] + 568446438; + a = (a << 5 | a >>> 27) + b << 0; + d += (b ^ (c & (a ^ b))) + blocks[14] - 1019803690; + d = (d << 9 | d >>> 23) + a << 0; + c += (a ^ (b & (d ^ a))) + blocks[3] - 187363961; + c = (c << 14 | c >>> 18) + d << 0; + b += (d ^ (a & (c ^ d))) + blocks[8] + 1163531501; + b = (b << 20 | b >>> 12) + c << 0; + a += (c ^ (d & (b ^ c))) + blocks[13] - 1444681467; + a = (a << 5 | a >>> 27) + b << 0; + d += (b ^ (c & (a ^ b))) + blocks[2] - 51403784; + d = (d << 9 | d >>> 23) + a << 0; + c += (a ^ (b & (d ^ a))) + blocks[7] + 1735328473; + c = (c << 14 | c >>> 18) + d << 0; + b += (d ^ (a & (c ^ d))) + blocks[12] - 1926607734; + b = (b << 20 | b >>> 12) + c << 0; + bc = b ^ c; + a += (bc ^ d) + blocks[5] - 378558; + a = (a << 4 | a >>> 28) + b << 0; + d += (bc ^ a) + blocks[8] - 2022574463; + d = (d << 11 | d >>> 21) + a << 0; + da = d ^ a; + c += (da ^ b) + blocks[11] + 1839030562; + c = (c << 16 | c >>> 16) + d << 0; + b += (da ^ c) + blocks[14] - 35309556; + b = (b << 23 | b >>> 9) + c << 0; + bc = b ^ c; + a += (bc ^ d) + blocks[1] - 1530992060; + a = (a << 4 | a >>> 28) + b << 0; + d += (bc ^ a) + blocks[4] + 1272893353; + d = (d << 11 | d >>> 21) + a << 0; + da = d ^ a; + c += (da ^ b) + blocks[7] - 155497632; + c = (c << 16 | c >>> 16) + d << 0; + b += (da ^ c) + blocks[10] - 1094730640; + b = (b << 23 | b >>> 9) + c << 0; + bc = b ^ c; + a += (bc ^ d) + blocks[13] + 681279174; + a = (a << 4 | a >>> 28) + b << 0; + d += (bc ^ a) + blocks[0] - 358537222; + d = (d << 11 | d >>> 21) + a << 0; + da = d ^ a; + c += (da ^ b) + blocks[3] - 722521979; + c = (c << 16 | c >>> 16) + d << 0; + b += (da ^ c) + blocks[6] + 76029189; + b = (b << 23 | b >>> 9) + c << 0; + bc = b ^ c; + a += (bc ^ d) + blocks[9] - 640364487; + a = (a << 4 | a >>> 28) + b << 0; + d += (bc ^ a) + blocks[12] - 421815835; + d = (d << 11 | d >>> 21) + a << 0; + da = d ^ a; + c += (da ^ b) + blocks[15] + 530742520; + c = (c << 16 | c >>> 16) + d << 0; + b += (da ^ c) + blocks[2] - 995338651; + b = (b << 23 | b >>> 9) + c << 0; + a += (c ^ (b | ~d)) + blocks[0] - 198630844; + a = (a << 6 | a >>> 26) + b << 0; + d += (b ^ (a | ~c)) + blocks[7] + 1126891415; + d = (d << 10 | d >>> 22) + a << 0; + c += (a ^ (d | ~b)) + blocks[14] - 1416354905; + c = (c << 15 | c >>> 17) + d << 0; + b += (d ^ (c | ~a)) + blocks[5] - 57434055; + b = (b << 21 | b >>> 11) + c << 0; + a += (c ^ (b | ~d)) + blocks[12] + 1700485571; + a = (a << 6 | a >>> 26) + b << 0; + d += (b ^ (a | ~c)) + blocks[3] - 1894986606; + d = (d << 10 | d >>> 22) + a << 0; + c += (a ^ (d | ~b)) + blocks[10] - 1051523; + c = (c << 15 | c >>> 17) + d << 0; + b += (d ^ (c | ~a)) + blocks[1] - 2054922799; + b = (b << 21 | b >>> 11) + c << 0; + a += (c ^ (b | ~d)) + blocks[8] + 1873313359; + a = (a << 6 | a >>> 26) + b << 0; + d += (b ^ (a | ~c)) + blocks[15] - 30611744; + d = (d << 10 | d >>> 22) + a << 0; + c += (a ^ (d | ~b)) + blocks[6] - 1560198380; + c = (c << 15 | c >>> 17) + d << 0; + b += (d ^ (c | ~a)) + blocks[13] + 1309151649; + b = (b << 21 | b >>> 11) + c << 0; + a += (c ^ (b | ~d)) + blocks[4] - 145523070; + a = (a << 6 | a >>> 26) + b << 0; + d += (b ^ (a | ~c)) + blocks[11] - 1120210379; + d = (d << 10 | d >>> 22) + a << 0; + c += (a ^ (d | ~b)) + blocks[2] + 718787259; + c = (c << 15 | c >>> 17) + d << 0; + b += (d ^ (c | ~a)) + blocks[9] - 343485551; + b = (b << 21 | b >>> 11) + c << 0; + + if (this.first) { + this.h0 = a + 1732584193 << 0; + this.h1 = b - 271733879 << 0; + this.h2 = c - 1732584194 << 0; + this.h3 = d + 271733878 << 0; + this.first = false; + } else { + this.h0 = this.h0 + a << 0; + this.h1 = this.h1 + b << 0; + this.h2 = this.h2 + c << 0; + this.h3 = this.h3 + d << 0; + } + }; + + /** + * @method hex + * @memberof Md5 + * @instance + * @description Output hash as hex string + * @returns {String} Hex string + * @see {@link md5.hex} + * @example + * hash.hex(); + */ + Md5.prototype.hex = function () { + this.finalize(); + + var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3; + + return HEX_CHARS[(h0 >>> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] + + HEX_CHARS[(h0 >>> 12) & 0x0F] + HEX_CHARS[(h0 >>> 8) & 0x0F] + + HEX_CHARS[(h0 >>> 20) & 0x0F] + HEX_CHARS[(h0 >>> 16) & 0x0F] + + HEX_CHARS[(h0 >>> 28) & 0x0F] + HEX_CHARS[(h0 >>> 24) & 0x0F] + + HEX_CHARS[(h1 >>> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] + + HEX_CHARS[(h1 >>> 12) & 0x0F] + HEX_CHARS[(h1 >>> 8) & 0x0F] + + HEX_CHARS[(h1 >>> 20) & 0x0F] + HEX_CHARS[(h1 >>> 16) & 0x0F] + + HEX_CHARS[(h1 >>> 28) & 0x0F] + HEX_CHARS[(h1 >>> 24) & 0x0F] + + HEX_CHARS[(h2 >>> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] + + HEX_CHARS[(h2 >>> 12) & 0x0F] + HEX_CHARS[(h2 >>> 8) & 0x0F] + + HEX_CHARS[(h2 >>> 20) & 0x0F] + HEX_CHARS[(h2 >>> 16) & 0x0F] + + HEX_CHARS[(h2 >>> 28) & 0x0F] + HEX_CHARS[(h2 >>> 24) & 0x0F] + + HEX_CHARS[(h3 >>> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] + + HEX_CHARS[(h3 >>> 12) & 0x0F] + HEX_CHARS[(h3 >>> 8) & 0x0F] + + HEX_CHARS[(h3 >>> 20) & 0x0F] + HEX_CHARS[(h3 >>> 16) & 0x0F] + + HEX_CHARS[(h3 >>> 28) & 0x0F] + HEX_CHARS[(h3 >>> 24) & 0x0F]; + }; + + /** + * @method toString + * @memberof Md5 + * @instance + * @description Output hash as hex string + * @returns {String} Hex string + * @see {@link md5.hex} + * @example + * hash.toString(); + */ + Md5.prototype.toString = Md5.prototype.hex; + + /** + * @method digest + * @memberof Md5 + * @instance + * @description Output hash as bytes array + * @returns {Array} Bytes array + * @see {@link md5.digest} + * @example + * hash.digest(); + */ + Md5.prototype.digest = function () { + this.finalize(); + + var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3; + return [ + h0 & 0xFF, (h0 >>> 8) & 0xFF, (h0 >>> 16) & 0xFF, (h0 >>> 24) & 0xFF, + h1 & 0xFF, (h1 >>> 8) & 0xFF, (h1 >>> 16) & 0xFF, (h1 >>> 24) & 0xFF, + h2 & 0xFF, (h2 >>> 8) & 0xFF, (h2 >>> 16) & 0xFF, (h2 >>> 24) & 0xFF, + h3 & 0xFF, (h3 >>> 8) & 0xFF, (h3 >>> 16) & 0xFF, (h3 >>> 24) & 0xFF + ]; + }; + + /** + * @method array + * @memberof Md5 + * @instance + * @description Output hash as bytes array + * @returns {Array} Bytes array + * @see {@link md5.array} + * @example + * hash.array(); + */ + Md5.prototype.array = Md5.prototype.digest; + + /** + * @method arrayBuffer + * @memberof Md5 + * @instance + * @description Output hash as ArrayBuffer + * @returns {ArrayBuffer} ArrayBuffer + * @see {@link md5.arrayBuffer} + * @example + * hash.arrayBuffer(); + */ + Md5.prototype.arrayBuffer = function () { + this.finalize(); + + var buffer = new ArrayBuffer(16); + var blocks = new Uint32Array(buffer); + blocks[0] = this.h0; + blocks[1] = this.h1; + blocks[2] = this.h2; + blocks[3] = this.h3; + return buffer; + }; + + /** + * @method buffer + * @deprecated This maybe confuse with Buffer in node.js. Please use arrayBuffer instead. + * @memberof Md5 + * @instance + * @description Output hash as ArrayBuffer + * @returns {ArrayBuffer} ArrayBuffer + * @see {@link md5.buffer} + * @example + * hash.buffer(); + */ + Md5.prototype.buffer = Md5.prototype.arrayBuffer; + + /** + * @method base64 + * @memberof Md5 + * @instance + * @description Output hash as base64 string + * @returns {String} base64 string + * @see {@link md5.base64} + * @example + * hash.base64(); + */ + Md5.prototype.base64 = function () { + var v1, v2, v3, base64Str = '', bytes = this.array(); + for (var i = 0; i < 15;) { + v1 = bytes[i++]; + v2 = bytes[i++]; + v3 = bytes[i++]; + base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] + + BASE64_ENCODE_CHAR[(v1 << 4 | v2 >>> 4) & 63] + + BASE64_ENCODE_CHAR[(v2 << 2 | v3 >>> 6) & 63] + + BASE64_ENCODE_CHAR[v3 & 63]; + } + v1 = bytes[i]; + base64Str += BASE64_ENCODE_CHAR[v1 >>> 2] + + BASE64_ENCODE_CHAR[(v1 << 4) & 63] + + '=='; + return base64Str; + }; + + /** + * HmacMd5 class + * @class HmacMd5 + * @extends Md5 + * @description This is internal class. + * @see {@link md5.hmac.create} + */ + function HmacMd5(key, sharedMemory) { + var i, result = formatMessage(key); + key = result[0]; + if (result[1]) { + var bytes = [], length = key.length, index = 0, code; + for (i = 0; i < length; ++i) { + code = key.charCodeAt(i); + if (code < 0x80) { + bytes[index++] = code; + } else if (code < 0x800) { + bytes[index++] = (0xc0 | (code >>> 6)); + bytes[index++] = (0x80 | (code & 0x3f)); + } else if (code < 0xd800 || code >= 0xe000) { + bytes[index++] = (0xe0 | (code >>> 12)); + bytes[index++] = (0x80 | ((code >>> 6) & 0x3f)); + bytes[index++] = (0x80 | (code & 0x3f)); + } else { + code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff)); + bytes[index++] = (0xf0 | (code >>> 18)); + bytes[index++] = (0x80 | ((code >>> 12) & 0x3f)); + bytes[index++] = (0x80 | ((code >>> 6) & 0x3f)); + bytes[index++] = (0x80 | (code & 0x3f)); + } + } + key = bytes; + } + + if (key.length > 64) { + key = (new Md5(true)).update(key).array(); + } + + var oKeyPad = [], iKeyPad = []; + for (i = 0; i < 64; ++i) { + var b = key[i] || 0; + oKeyPad[i] = 0x5c ^ b; + iKeyPad[i] = 0x36 ^ b; + } + + Md5.call(this, sharedMemory); + + this.update(iKeyPad); + this.oKeyPad = oKeyPad; + this.inner = true; + this.sharedMemory = sharedMemory; + } + HmacMd5.prototype = new Md5(); + + HmacMd5.prototype.finalize = function () { + Md5.prototype.finalize.call(this); + if (this.inner) { + this.inner = false; + var innerHash = this.array(); + Md5.call(this, this.sharedMemory); + this.update(this.oKeyPad); + this.update(innerHash); + Md5.prototype.finalize.call(this); + } + }; + + var exports = createMethod(); + exports.md5 = exports; + exports.md5.hmac = createHmacMethod(); + + if (COMMON_JS) { + module.exports = exports; + } else { + /** + * @method md5 + * @description Md5 hash function, export to global in browsers. + * @param {String|Array|Uint8Array|ArrayBuffer} message message to hash + * @returns {String} md5 hashes + * @example + * md5(''); // d41d8cd98f00b204e9800998ecf8427e + * md5('The quick brown fox jumps over the lazy dog'); // 9e107d9d372bb6826bd81d3542a419d6 + * md5('The quick brown fox jumps over the lazy dog.'); // e4d909c290d0fb1ca068ffaddf22cbd0 + * + * // It also supports UTF-8 encoding + * md5('中文'); // a7bac2239fcdcb3a067903d8077c4a07 + * + * // It also supports byte `Array`, `Uint8Array`, `ArrayBuffer` + * md5([]); // d41d8cd98f00b204e9800998ecf8427e + * md5(new Uint8Array([])); // d41d8cd98f00b204e9800998ecf8427e + */ + root.md5 = exports; + if (AMD) { + !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () { + return exports; + }).call(exports, __webpack_require__, exports, module), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } + } +})(); + + +/***/ }, + +/***/ 716 +(module) { + +"use strict"; + + +/** @type {import('./abs')} */ +module.exports = Math.abs; + + +/***/ }, + +/***/ 7450 +(module) { + +"use strict"; + + +/** @type {import('./floor')} */ +module.exports = Math.floor; + + +/***/ }, + +/***/ 713 +(module) { + +"use strict"; + + +/** @type {import('./isNaN')} */ +module.exports = Number.isNaN || function isNaN(a) { + return a !== a; +}; + + +/***/ }, + +/***/ 3774 +(module) { + +"use strict"; + + +/** @type {import('./max')} */ +module.exports = Math.max; + + +/***/ }, + +/***/ 7552 +(module) { + +"use strict"; + + +/** @type {import('./min')} */ +module.exports = Math.min; + + +/***/ }, + +/***/ 5874 +(module) { + +"use strict"; + + +/** @type {import('./pow')} */ +module.exports = Math.pow; + + +/***/ }, + +/***/ 9292 +(module) { + +"use strict"; + + +/** @type {import('./round')} */ +module.exports = Math.round; + + +/***/ }, + +/***/ 6071 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var $isNaN = __webpack_require__(713); + +/** @type {import('./sign')} */ +module.exports = function sign(number) { + if ($isNaN(number) || number === 0) { + return number; + } + return number < 0 ? -1 : +1; +}; + + +/***/ }, + +/***/ 3249 +(module) { + +"use strict"; + + +var numberIsNaN = function (value) { + return value !== value; +}; + +module.exports = function is(a, b) { + if (a === 0 && b === 0) { + return 1 / a === 1 / b; + } + if (a === b) { + return true; + } + if (numberIsNaN(a) && numberIsNaN(b)) { + return true; + } + return false; +}; + + + +/***/ }, + +/***/ 8527 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var define = __webpack_require__(5421); +var callBind = __webpack_require__(6601); + +var implementation = __webpack_require__(3249); +var getPolyfill = __webpack_require__(9636); +var shim = __webpack_require__(3534); + +var polyfill = callBind(getPolyfill(), Object); + +define(polyfill, { + getPolyfill: getPolyfill, + implementation: implementation, + shim: shim +}); + +module.exports = polyfill; + + +/***/ }, + +/***/ 9636 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var implementation = __webpack_require__(3249); + +module.exports = function getPolyfill() { + return typeof Object.is === 'function' ? Object.is : implementation; +}; + + +/***/ }, + +/***/ 3534 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var getPolyfill = __webpack_require__(9636); +var define = __webpack_require__(5421); + +module.exports = function shimObjectIs() { + var polyfill = getPolyfill(); + define(Object, { is: polyfill }, { + is: function testObjectIs() { + return Object.is !== polyfill; + } + }); + return polyfill; +}; + + +/***/ }, + +/***/ 8461 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var keysShim; +if (!Object.keys) { + // modified from https://github.com/es-shims/es5-shim + var has = Object.prototype.hasOwnProperty; + var toStr = Object.prototype.toString; + var isArgs = __webpack_require__(6515); // eslint-disable-line global-require + var isEnumerable = Object.prototype.propertyIsEnumerable; + var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString'); + var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype'); + var dontEnums = [ + 'toString', + 'toLocaleString', + 'valueOf', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'constructor' + ]; + var equalsConstructorPrototype = function (o) { + var ctor = o.constructor; + return ctor && ctor.prototype === o; + }; + var excludedKeys = { + $applicationCache: true, + $console: true, + $external: true, + $frame: true, + $frameElement: true, + $frames: true, + $innerHeight: true, + $innerWidth: true, + $onmozfullscreenchange: true, + $onmozfullscreenerror: true, + $outerHeight: true, + $outerWidth: true, + $pageXOffset: true, + $pageYOffset: true, + $parent: true, + $scrollLeft: true, + $scrollTop: true, + $scrollX: true, + $scrollY: true, + $self: true, + $webkitIndexedDB: true, + $webkitStorageInfo: true, + $window: true + }; + var hasAutomationEqualityBug = (function () { + /* global window */ + if (typeof window === 'undefined') { return false; } + for (var k in window) { + try { + if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') { + try { + equalsConstructorPrototype(window[k]); + } catch (e) { + return true; + } + } + } catch (e) { + return true; + } + } + return false; + }()); + var equalsConstructorPrototypeIfNotBuggy = function (o) { + /* global window */ + if (typeof window === 'undefined' || !hasAutomationEqualityBug) { + return equalsConstructorPrototype(o); + } + try { + return equalsConstructorPrototype(o); + } catch (e) { + return false; + } + }; + + keysShim = function keys(object) { + var isObject = object !== null && typeof object === 'object'; + var isFunction = toStr.call(object) === '[object Function]'; + var isArguments = isArgs(object); + var isString = isObject && toStr.call(object) === '[object String]'; + var theKeys = []; + + if (!isObject && !isFunction && !isArguments) { + throw new TypeError('Object.keys called on a non-object'); + } + + var skipProto = hasProtoEnumBug && isFunction; + if (isString && object.length > 0 && !has.call(object, 0)) { + for (var i = 0; i < object.length; ++i) { + theKeys.push(String(i)); + } + } + + if (isArguments && object.length > 0) { + for (var j = 0; j < object.length; ++j) { + theKeys.push(String(j)); + } + } else { + for (var name in object) { + if (!(skipProto && name === 'prototype') && has.call(object, name)) { + theKeys.push(String(name)); + } + } + } + + if (hasDontEnumBug) { + var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object); + + for (var k = 0; k < dontEnums.length; ++k) { + if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) { + theKeys.push(dontEnums[k]); + } + } + } + return theKeys; + }; +} +module.exports = keysShim; + + +/***/ }, + +/***/ 5643 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var slice = Array.prototype.slice; +var isArgs = __webpack_require__(6515); + +var origKeys = Object.keys; +var keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__(8461); + +var originalKeys = Object.keys; + +keysShim.shim = function shimObjectKeys() { + if (Object.keys) { + var keysWorksWithArguments = (function () { + // Safari 5.0 bug + var args = Object.keys(arguments); + return args && args.length === arguments.length; + }(1, 2)); + if (!keysWorksWithArguments) { + Object.keys = function keys(object) { // eslint-disable-line func-name-matching + if (isArgs(object)) { + return originalKeys(slice.call(object)); + } + return originalKeys(object); + }; + } + } else { + Object.keys = keysShim; + } + return Object.keys || keysShim; +}; + +module.exports = keysShim; + + +/***/ }, + +/***/ 6515 +(module) { + +"use strict"; + + +var toStr = Object.prototype.toString; + +module.exports = function isArguments(value) { + var str = toStr.call(value); + var isArgs = str === '[object Arguments]'; + if (!isArgs) { + isArgs = str !== '[object Array]' && + value !== null && + typeof value === 'object' && + typeof value.length === 'number' && + value.length >= 0 && + toStr.call(value.callee) === '[object Function]'; + } + return isArgs; +}; + + +/***/ }, + +/***/ 6521 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +// modified from https://github.com/es-shims/es6-shim +var objectKeys = __webpack_require__(5643); +var hasSymbols = __webpack_require__(2843)(); +var callBound = __webpack_require__(2774); +var $Object = __webpack_require__(5846); +var $push = callBound('Array.prototype.push'); +var $propIsEnumerable = callBound('Object.prototype.propertyIsEnumerable'); +var originalGetSymbols = hasSymbols ? $Object.getOwnPropertySymbols : null; + +// eslint-disable-next-line no-unused-vars +module.exports = function assign(target, source1) { + if (target == null) { throw new TypeError('target must be an object'); } + var to = $Object(target); // step 1 + if (arguments.length === 1) { + return to; // step 2 + } + for (var s = 1; s < arguments.length; ++s) { + var from = $Object(arguments[s]); // step 3.a.i + + // step 3.a.ii: + var keys = objectKeys(from); + var getSymbols = hasSymbols && ($Object.getOwnPropertySymbols || originalGetSymbols); + if (getSymbols) { + var syms = getSymbols(from); + for (var j = 0; j < syms.length; ++j) { + var key = syms[j]; + if ($propIsEnumerable(from, key)) { + $push(keys, key); + } + } + } + + // step 3.a.iii: + for (var i = 0; i < keys.length; ++i) { + var nextKey = keys[i]; + if ($propIsEnumerable(from, nextKey)) { // step 3.a.iii.2 + var propValue = from[nextKey]; // step 3.a.iii.2.a + to[nextKey] = propValue; // step 3.a.iii.2.b + } + } + } + + return to; // step 4 +}; + + +/***/ }, + +/***/ 7596 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var implementation = __webpack_require__(6521); + +var lacksProperEnumerationOrder = function () { + if (!Object.assign) { + return false; + } + /* + * v8, specifically in node 4.x, has a bug with incorrect property enumeration order + * note: this does not detect the bug unless there's 20 characters + */ + var str = 'abcdefghijklmnopqrst'; + var letters = str.split(''); + var map = {}; + for (var i = 0; i < letters.length; ++i) { + map[letters[i]] = letters[i]; + } + var obj = Object.assign({}, map); + var actual = ''; + for (var k in obj) { + actual += k; + } + return str !== actual; +}; + +var assignHasPendingExceptions = function () { + if (!Object.assign || !Object.preventExtensions) { + return false; + } + /* + * Firefox 37 still has "pending exception" logic in its Object.assign implementation, + * which is 72% slower than our shim, and Firefox 40's native implementation. + */ + var thrower = Object.preventExtensions({ 1: 2 }); + try { + Object.assign(thrower, 'xy'); + } catch (e) { + return thrower[1] === 'y'; + } + return false; +}; + +module.exports = function getPolyfill() { + if (!Object.assign) { + return implementation; + } + if (lacksProperEnumerationOrder()) { + return implementation; + } + if (assignHasPendingExceptions()) { + return implementation; + } + return Object.assign; +}; + + +/***/ }, + +/***/ 2519 +(__unused_webpack_module, exports) { + +"use strict"; + + + +var TYPED_OK = (typeof Uint8Array !== 'undefined') && + (typeof Uint16Array !== 'undefined') && + (typeof Int32Array !== 'undefined'); + +function _has(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +} + +exports.assign = function (obj /*from1, from2, from3, ...*/) { + var sources = Array.prototype.slice.call(arguments, 1); + while (sources.length) { + var source = sources.shift(); + if (!source) { continue; } + + if (typeof source !== 'object') { + throw new TypeError(source + 'must be non-object'); + } + + for (var p in source) { + if (_has(source, p)) { + obj[p] = source[p]; + } + } + } + + return obj; +}; + + +// reduce buffer size, avoiding mem copy +exports.shrinkBuf = function (buf, size) { + if (buf.length === size) { return buf; } + if (buf.subarray) { return buf.subarray(0, size); } + buf.length = size; + return buf; +}; + + +var fnTyped = { + arraySet: function (dest, src, src_offs, len, dest_offs) { + if (src.subarray && dest.subarray) { + dest.set(src.subarray(src_offs, src_offs + len), dest_offs); + return; + } + // Fallback to ordinary array + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function (chunks) { + var i, l, len, pos, chunk, result; + + // calculate data length + len = 0; + for (i = 0, l = chunks.length; i < l; i++) { + len += chunks[i].length; + } + + // join chunks + result = new Uint8Array(len); + pos = 0; + for (i = 0, l = chunks.length; i < l; i++) { + chunk = chunks[i]; + result.set(chunk, pos); + pos += chunk.length; + } + + return result; + } +}; + +var fnUntyped = { + arraySet: function (dest, src, src_offs, len, dest_offs) { + for (var i = 0; i < len; i++) { + dest[dest_offs + i] = src[src_offs + i]; + } + }, + // Join array of chunks to single array. + flattenChunks: function (chunks) { + return [].concat.apply([], chunks); + } +}; + + +// Enable/Disable typed arrays use, for testing +// +exports.setTyped = function (on) { + if (on) { + exports.Buf8 = Uint8Array; + exports.Buf16 = Uint16Array; + exports.Buf32 = Int32Array; + exports.assign(exports, fnTyped); + } else { + exports.Buf8 = Array; + exports.Buf16 = Array; + exports.Buf32 = Array; + exports.assign(exports, fnUntyped); + } +}; + +exports.setTyped(TYPED_OK); + + +/***/ }, + +/***/ 6911 +(module) { + +"use strict"; + + +// Note: adler32 takes 12% for level 0 and 2% for level 6. +// It isn't worth it to make additional optimizations as in original. +// Small size is preferable. + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +function adler32(adler, buf, len, pos) { + var s1 = (adler & 0xffff) |0, + s2 = ((adler >>> 16) & 0xffff) |0, + n = 0; + + while (len !== 0) { + // Set limit ~ twice less than 5552, to keep + // s2 in 31-bits, because we force signed ints. + // in other case %= will fail. + n = len > 2000 ? 2000 : len; + len -= n; + + do { + s1 = (s1 + buf[pos++]) |0; + s2 = (s2 + s1) |0; + } while (--n); + + s1 %= 65521; + s2 %= 65521; + } + + return (s1 | (s2 << 16)) |0; +} + + +module.exports = adler32; + + +/***/ }, + +/***/ 1607 +(module) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +module.exports = { + + /* Allowed flush values; see deflate() and inflate() below for details */ + Z_NO_FLUSH: 0, + Z_PARTIAL_FLUSH: 1, + Z_SYNC_FLUSH: 2, + Z_FULL_FLUSH: 3, + Z_FINISH: 4, + Z_BLOCK: 5, + Z_TREES: 6, + + /* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + Z_OK: 0, + Z_STREAM_END: 1, + Z_NEED_DICT: 2, + Z_ERRNO: -1, + Z_STREAM_ERROR: -2, + Z_DATA_ERROR: -3, + //Z_MEM_ERROR: -4, + Z_BUF_ERROR: -5, + //Z_VERSION_ERROR: -6, + + /* compression levels */ + Z_NO_COMPRESSION: 0, + Z_BEST_SPEED: 1, + Z_BEST_COMPRESSION: 9, + Z_DEFAULT_COMPRESSION: -1, + + + Z_FILTERED: 1, + Z_HUFFMAN_ONLY: 2, + Z_RLE: 3, + Z_FIXED: 4, + Z_DEFAULT_STRATEGY: 0, + + /* Possible values of the data_type field (though see inflate()) */ + Z_BINARY: 0, + Z_TEXT: 1, + //Z_ASCII: 1, // = Z_TEXT (deprecated) + Z_UNKNOWN: 2, + + /* The deflate compression method */ + Z_DEFLATED: 8 + //Z_NULL: null // Use -1 or null inline, depending on var type +}; + + +/***/ }, + +/***/ 9049 +(module) { + +"use strict"; + + +// Note: we can't get significant speed boost here. +// So write code to minimize size - no pregenerated tables +// and array tools dependencies. + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +// Use ordinary array, since untyped makes no boost here +function makeTable() { + var c, table = []; + + for (var n = 0; n < 256; n++) { + c = n; + for (var k = 0; k < 8; k++) { + c = ((c & 1) ? (0xEDB88320 ^ (c >>> 1)) : (c >>> 1)); + } + table[n] = c; + } + + return table; +} + +// Create table on load. Just 255 signed longs. Not a problem. +var crcTable = makeTable(); + + +function crc32(crc, buf, len, pos) { + var t = crcTable, + end = pos + len; + + crc ^= -1; + + for (var i = pos; i < end; i++) { + crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xFF]; + } + + return (crc ^ (-1)); // >>> 0; +} + + +module.exports = crc32; + + +/***/ }, + +/***/ 2925 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +var utils = __webpack_require__(2519); +var trees = __webpack_require__(2367); +var adler32 = __webpack_require__(6911); +var crc32 = __webpack_require__(9049); +var msg = __webpack_require__(6228); + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +var Z_NO_FLUSH = 0; +var Z_PARTIAL_FLUSH = 1; +//var Z_SYNC_FLUSH = 2; +var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +//var Z_TREES = 6; + + +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +//var Z_NEED_DICT = 2; +//var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +//var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +//var Z_VERSION_ERROR = -6; + + +/* compression levels */ +//var Z_NO_COMPRESSION = 0; +//var Z_BEST_SPEED = 1; +//var Z_BEST_COMPRESSION = 9; +var Z_DEFAULT_COMPRESSION = -1; + + +var Z_FILTERED = 1; +var Z_HUFFMAN_ONLY = 2; +var Z_RLE = 3; +var Z_FIXED = 4; +var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +//var Z_BINARY = 0; +//var Z_TEXT = 1; +//var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + + +/* The deflate compression method */ +var Z_DEFLATED = 8; + +/*============================================================================*/ + + +var MAX_MEM_LEVEL = 9; +/* Maximum value for memLevel in deflateInit2 */ +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_MEM_LEVEL = 8; + + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ +var LITERALS = 256; +/* number of literal bytes 0..255 */ +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ +var D_CODES = 30; +/* number of distance codes */ +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ +var HEAP_SIZE = 2 * L_CODES + 1; +/* maximum heap size */ +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +var MIN_LOOKAHEAD = (MAX_MATCH + MIN_MATCH + 1); + +var PRESET_DICT = 0x20; + +var INIT_STATE = 42; +var EXTRA_STATE = 69; +var NAME_STATE = 73; +var COMMENT_STATE = 91; +var HCRC_STATE = 103; +var BUSY_STATE = 113; +var FINISH_STATE = 666; + +var BS_NEED_MORE = 1; /* block not completed, need more input or more output */ +var BS_BLOCK_DONE = 2; /* block flush performed */ +var BS_FINISH_STARTED = 3; /* finish started, need only more output at next deflate */ +var BS_FINISH_DONE = 4; /* finish done, accept no more input or output */ + +var OS_CODE = 0x03; // Unix :) . Don't detect, use this default. + +function err(strm, errorCode) { + strm.msg = msg[errorCode]; + return errorCode; +} + +function rank(f) { + return ((f) << 1) - ((f) > 4 ? 9 : 0); +} + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->output buffer and copying into it. + * (See also read_buf()). + */ +function flush_pending(strm) { + var s = strm.state; + + //_tr_flush_bits(s); + var len = s.pending; + if (len > strm.avail_out) { + len = strm.avail_out; + } + if (len === 0) { return; } + + utils.arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out); + strm.next_out += len; + s.pending_out += len; + strm.total_out += len; + strm.avail_out -= len; + s.pending -= len; + if (s.pending === 0) { + s.pending_out = 0; + } +} + + +function flush_block_only(s, last) { + trees._tr_flush_block(s, (s.block_start >= 0 ? s.block_start : -1), s.strstart - s.block_start, last); + s.block_start = s.strstart; + flush_pending(s.strm); +} + + +function put_byte(s, b) { + s.pending_buf[s.pending++] = b; +} + + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +function putShortMSB(s, b) { +// put_byte(s, (Byte)(b >> 8)); +// put_byte(s, (Byte)(b & 0xff)); + s.pending_buf[s.pending++] = (b >>> 8) & 0xff; + s.pending_buf[s.pending++] = b & 0xff; +} + + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->input buffer and copying from it. + * (See also flush_pending()). + */ +function read_buf(strm, buf, start, size) { + var len = strm.avail_in; + + if (len > size) { len = size; } + if (len === 0) { return 0; } + + strm.avail_in -= len; + + // zmemcpy(buf, strm->next_in, len); + utils.arraySet(buf, strm.input, strm.next_in, len, start); + if (strm.state.wrap === 1) { + strm.adler = adler32(strm.adler, buf, len, start); + } + + else if (strm.state.wrap === 2) { + strm.adler = crc32(strm.adler, buf, len, start); + } + + strm.next_in += len; + strm.total_in += len; + + return len; +} + + +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +function longest_match(s, cur_match) { + var chain_length = s.max_chain_length; /* max hash chain length */ + var scan = s.strstart; /* current string */ + var match; /* matched string */ + var len; /* length of current match */ + var best_len = s.prev_length; /* best match length so far */ + var nice_match = s.nice_match; /* stop if match long enough */ + var limit = (s.strstart > (s.w_size - MIN_LOOKAHEAD)) ? + s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0/*NIL*/; + + var _win = s.window; // shortcut + + var wmask = s.w_mask; + var prev = s.prev; + + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + + var strend = s.strstart + MAX_MATCH; + var scan_end1 = _win[scan + best_len - 1]; + var scan_end = _win[scan + best_len]; + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s.prev_length >= s.good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if (nice_match > s.lookahead) { nice_match = s.lookahead; } + + // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + // Assert(cur_match < s->strstart, "no future"); + match = cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2. Note that the checks below + * for insufficient lookahead only occur occasionally for performance + * reasons. Therefore uninitialized memory will be accessed, and + * conditional jumps will be made that depend on those values. + * However the length of the match is limited to the lookahead, so + * the output of deflate is not affected by the uninitialized values. + */ + + if (_win[match + best_len] !== scan_end || + _win[match + best_len - 1] !== scan_end1 || + _win[match] !== _win[scan] || + _win[++match] !== _win[scan + 1]) { + continue; + } + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2; + match++; + // Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + /*jshint noempty:false*/ + } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && + scan < strend); + + // Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (strend - scan); + scan = strend - MAX_MATCH; + + if (len > best_len) { + s.match_start = cur_match; + best_len = len; + if (len >= nice_match) { + break; + } + scan_end1 = _win[scan + best_len - 1]; + scan_end = _win[scan + best_len]; + } + } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0); + + if (best_len <= s.lookahead) { + return best_len; + } + return s.lookahead; +} + + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +function fill_window(s) { + var _w_size = s.w_size; + var p, n, m, more, str; + + //Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = s.window_size - s.lookahead - s.strstart; + + // JS ints have 32 bit, block below not needed + /* Deal with !@#$% 64K limit: */ + //if (sizeof(int) <= 2) { + // if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + // more = wsize; + // + // } else if (more == (unsigned)(-1)) { + // /* Very unlikely, but possible on 16 bit machine if + // * strstart == 0 && lookahead == 1 (input done a byte at time) + // */ + // more--; + // } + //} + + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) { + + utils.arraySet(s.window, s.window, _w_size, _w_size, 0); + s.match_start -= _w_size; + s.strstart -= _w_size; + /* we now have strstart >= MAX_DIST */ + s.block_start -= _w_size; + + /* Slide the hash table (could be avoided with 32 bit values + at the expense of memory usage). We slide even when level == 0 + to keep the hash table consistent if we switch back to level > 0 + later. (Using level 0 permanently is not an optimal usage of + zlib, so we don't care about this pathological case.) + */ + + n = s.hash_size; + p = n; + do { + m = s.head[--p]; + s.head[p] = (m >= _w_size ? m - _w_size : 0); + } while (--n); + + n = _w_size; + p = n; + do { + m = s.prev[--p]; + s.prev[p] = (m >= _w_size ? m - _w_size : 0); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); + + more += _w_size; + } + if (s.strm.avail_in === 0) { + break; + } + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + //Assert(more >= 2, "more < 2"); + n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more); + s.lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s.lookahead + s.insert >= MIN_MATCH) { + str = s.strstart - s.insert; + s.ins_h = s.window[str]; + + /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + 1]) & s.hash_mask; +//#if MIN_MATCH != 3 +// Call update_hash() MIN_MATCH-3 more times +//#endif + while (s.insert) { + /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + + s.prev[str & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = str; + str++; + s.insert--; + if (s.lookahead + s.insert < MIN_MATCH) { + break; + } + } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0); + + /* If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by + * the longest match routines. Update the high water mark for the next + * time through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ +// if (s.high_water < s.window_size) { +// var curr = s.strstart + s.lookahead; +// var init = 0; +// +// if (s.high_water < curr) { +// /* Previous high water mark below current data -- zero WIN_INIT +// * bytes or up to end of window, whichever is less. +// */ +// init = s.window_size - curr; +// if (init > WIN_INIT) +// init = WIN_INIT; +// zmemzero(s->window + curr, (unsigned)init); +// s->high_water = curr + init; +// } +// else if (s->high_water < (ulg)curr + WIN_INIT) { +// /* High water mark at or above current data, but below current data +// * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up +// * to end of window, whichever is less. +// */ +// init = (ulg)curr + WIN_INIT - s->high_water; +// if (init > s->window_size - s->high_water) +// init = s->window_size - s->high_water; +// zmemzero(s->window + s->high_water, (unsigned)init); +// s->high_water += init; +// } +// } +// +// Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, +// "not enough room for search"); +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +function deflate_stored(s, flush) { + /* Stored blocks are limited to 0xffff bytes, pending_buf is limited + * to pending_buf_size, and each stored block has a 5 byte header: + */ + var max_block_size = 0xffff; + + if (max_block_size > s.pending_buf_size - 5) { + max_block_size = s.pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s.lookahead <= 1) { + + //Assert(s->strstart < s->w_size+MAX_DIST(s) || + // s->block_start >= (long)s->w_size, "slide too late"); +// if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) || +// s.block_start >= s.w_size)) { +// throw new Error("slide too late"); +// } + + fill_window(s); + if (s.lookahead === 0 && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + + if (s.lookahead === 0) { + break; + } + /* flush the current block */ + } + //Assert(s->block_start >= 0L, "block gone"); +// if (s.block_start < 0) throw new Error("block gone"); + + s.strstart += s.lookahead; + s.lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + var max_start = s.block_start + max_block_size; + + if (s.strstart === 0 || s.strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s.lookahead = s.strstart - max_start; + s.strstart = max_start; + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + + + } + /* Flush if we may have to slide, otherwise block_start may become + * negative and the data will be gone: + */ + if (s.strstart - s.block_start >= (s.w_size - MIN_LOOKAHEAD)) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + + s.insert = 0; + + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + + if (s.strstart > s.block_start) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_NEED_MORE; +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +function deflate_fast(s, flush) { + var hash_head; /* head of the hash chain */ + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { + break; /* flush the current block */ + } + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = 0/*NIL*/; + if (s.lookahead >= MIN_MATCH) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head !== 0/*NIL*/ && ((s.strstart - hash_head) <= (s.w_size - MIN_LOOKAHEAD))) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + } + if (s.match_length >= MIN_MATCH) { + // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only + + /*** _tr_tally_dist(s, s.strstart - s.match_start, + s.match_length - MIN_MATCH, bflush); ***/ + bflush = trees._tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ + if (s.match_length <= s.max_lazy_match/*max_insert_length*/ && s.lookahead >= MIN_MATCH) { + s.match_length--; /* string at strstart already in table */ + do { + s.strstart++; + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. + */ + } while (--s.match_length !== 0); + s.strstart++; + } else + { + s.strstart += s.match_length; + s.match_length = 0; + s.ins_h = s.window[s.strstart]; + /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + 1]) & s.hash_mask; + +//#if MIN_MATCH != 3 +// Call UPDATE_HASH() MIN_MATCH-3 more times +//#endif + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + //Tracevv((stderr,"%c", s.window[s.strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = ((s.strstart < (MIN_MATCH - 1)) ? s.strstart : MIN_MATCH - 1); + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +function deflate_slow(s, flush) { + var hash_head; /* head of hash chain */ + var bflush; /* set if current block must be flushed */ + + var max_insert; + + /* Process the input block. */ + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s.lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = 0/*NIL*/; + if (s.lookahead >= MIN_MATCH) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + + /* Find the longest match, discarding those <= prev_length. + */ + s.prev_length = s.match_length; + s.prev_match = s.match_start; + s.match_length = MIN_MATCH - 1; + + if (hash_head !== 0/*NIL*/ && s.prev_length < s.max_lazy_match && + s.strstart - hash_head <= (s.w_size - MIN_LOOKAHEAD)/*MAX_DIST(s)*/) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s.match_length = longest_match(s, hash_head); + /* longest_match() sets match_start */ + + if (s.match_length <= 5 && + (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH && s.strstart - s.match_start > 4096/*TOO_FAR*/))) { + + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + s.match_length = MIN_MATCH - 1; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (s.prev_length >= MIN_MATCH && s.match_length <= s.prev_length) { + max_insert = s.strstart + s.lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + //check_match(s, s.strstart-1, s.prev_match, s.prev_length); + + /***_tr_tally_dist(s, s.strstart - 1 - s.prev_match, + s.prev_length - MIN_MATCH, bflush);***/ + bflush = trees._tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH); + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not + * enough lookahead, the last two strings are not inserted in + * the hash table. + */ + s.lookahead -= s.prev_length - 1; + s.prev_length -= 2; + do { + if (++s.strstart <= max_insert) { + /*** INSERT_STRING(s, s.strstart, hash_head); ***/ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[s.strstart + MIN_MATCH - 1]) & s.hash_mask; + hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h]; + s.head[s.ins_h] = s.strstart; + /***/ + } + } while (--s.prev_length !== 0); + s.match_available = 0; + s.match_length = MIN_MATCH - 1; + s.strstart++; + + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + } else if (s.match_available) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + //Tracevv((stderr,"%c", s->window[s->strstart-1])); + /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + + if (bflush) { + /*** FLUSH_BLOCK_ONLY(s, 0) ***/ + flush_block_only(s, false); + /***/ + } + s.strstart++; + s.lookahead--; + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + s.match_available = 1; + s.strstart++; + s.lookahead--; + } + } + //Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s.match_available) { + //Tracevv((stderr,"%c", s->window[s->strstart-1])); + /*** _tr_tally_lit(s, s.window[s.strstart-1], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart - 1]); + + s.match_available = 0; + } + s.insert = s.strstart < MIN_MATCH - 1 ? s.strstart : MIN_MATCH - 1; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + + return BS_BLOCK_DONE; +} + + +/* =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +function deflate_rle(s, flush) { + var bflush; /* set if current block must be flushed */ + var prev; /* byte at distance one to match */ + var scan, strend; /* scan goes up to strend for length of run */ + + var _win = s.window; + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the longest run, plus one for the unrolled loop. + */ + if (s.lookahead <= MAX_MATCH) { + fill_window(s); + if (s.lookahead <= MAX_MATCH && flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + if (s.lookahead === 0) { break; } /* flush the current block */ + } + + /* See how many times the previous byte repeats */ + s.match_length = 0; + if (s.lookahead >= MIN_MATCH && s.strstart > 0) { + scan = s.strstart - 1; + prev = _win[scan]; + if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) { + strend = s.strstart + MAX_MATCH; + do { + /*jshint noempty:false*/ + } while (prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + prev === _win[++scan] && prev === _win[++scan] && + scan < strend); + s.match_length = MAX_MATCH - (strend - scan); + if (s.match_length > s.lookahead) { + s.match_length = s.lookahead; + } + } + //Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ + if (s.match_length >= MIN_MATCH) { + //check_match(s, s.strstart, s.strstart - 1, s.match_length); + + /*** _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ***/ + bflush = trees._tr_tally(s, 1, s.match_length - MIN_MATCH); + + s.lookahead -= s.match_length; + s.strstart += s.match_length; + s.match_length = 0; + } else { + /* No match, output a literal byte */ + //Tracevv((stderr,"%c", s->window[s->strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + + s.lookahead--; + s.strstart++; + } + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +function deflate_huff(s, flush) { + var bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we have a literal to write. */ + if (s.lookahead === 0) { + fill_window(s); + if (s.lookahead === 0) { + if (flush === Z_NO_FLUSH) { + return BS_NEED_MORE; + } + break; /* flush the current block */ + } + } + + /* Output a literal byte */ + s.match_length = 0; + //Tracevv((stderr,"%c", s->window[s->strstart])); + /*** _tr_tally_lit(s, s.window[s.strstart], bflush); ***/ + bflush = trees._tr_tally(s, 0, s.window[s.strstart]); + s.lookahead--; + s.strstart++; + if (bflush) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + } + s.insert = 0; + if (flush === Z_FINISH) { + /*** FLUSH_BLOCK(s, 1); ***/ + flush_block_only(s, true); + if (s.strm.avail_out === 0) { + return BS_FINISH_STARTED; + } + /***/ + return BS_FINISH_DONE; + } + if (s.last_lit) { + /*** FLUSH_BLOCK(s, 0); ***/ + flush_block_only(s, false); + if (s.strm.avail_out === 0) { + return BS_NEED_MORE; + } + /***/ + } + return BS_BLOCK_DONE; +} + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +function Config(good_length, max_lazy, nice_length, max_chain, func) { + this.good_length = good_length; + this.max_lazy = max_lazy; + this.nice_length = nice_length; + this.max_chain = max_chain; + this.func = func; +} + +var configuration_table; + +configuration_table = [ + /* good lazy nice chain */ + new Config(0, 0, 0, 0, deflate_stored), /* 0 store only */ + new Config(4, 4, 8, 4, deflate_fast), /* 1 max speed, no lazy matches */ + new Config(4, 5, 16, 8, deflate_fast), /* 2 */ + new Config(4, 6, 32, 32, deflate_fast), /* 3 */ + + new Config(4, 4, 16, 16, deflate_slow), /* 4 lazy matches */ + new Config(8, 16, 32, 32, deflate_slow), /* 5 */ + new Config(8, 16, 128, 128, deflate_slow), /* 6 */ + new Config(8, 32, 128, 256, deflate_slow), /* 7 */ + new Config(32, 128, 258, 1024, deflate_slow), /* 8 */ + new Config(32, 258, 258, 4096, deflate_slow) /* 9 max compression */ +]; + + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +function lm_init(s) { + s.window_size = 2 * s.w_size; + + /*** CLEAR_HASH(s); ***/ + zero(s.head); // Fill with NIL (= 0); + + /* Set the default configuration parameters: + */ + s.max_lazy_match = configuration_table[s.level].max_lazy; + s.good_match = configuration_table[s.level].good_length; + s.nice_match = configuration_table[s.level].nice_length; + s.max_chain_length = configuration_table[s.level].max_chain; + + s.strstart = 0; + s.block_start = 0; + s.lookahead = 0; + s.insert = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + s.ins_h = 0; +} + + +function DeflateState() { + this.strm = null; /* pointer back to this zlib stream */ + this.status = 0; /* as the name implies */ + this.pending_buf = null; /* output still pending */ + this.pending_buf_size = 0; /* size of pending_buf */ + this.pending_out = 0; /* next pending byte to output to the stream */ + this.pending = 0; /* nb of bytes in the pending buffer */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.gzhead = null; /* gzip header information to write */ + this.gzindex = 0; /* where in extra, name, or comment */ + this.method = Z_DEFLATED; /* can only be DEFLATED */ + this.last_flush = -1; /* value of flush param for previous deflate call */ + + this.w_size = 0; /* LZ77 window size (32K by default) */ + this.w_bits = 0; /* log2(w_size) (8..16) */ + this.w_mask = 0; /* w_size - 1 */ + + this.window = null; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. + */ + + this.window_size = 0; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + this.prev = null; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + this.head = null; /* Heads of the hash chains or NIL. */ + + this.ins_h = 0; /* hash index of string to be inserted */ + this.hash_size = 0; /* number of elements in hash table */ + this.hash_bits = 0; /* log2(hash_size) */ + this.hash_mask = 0; /* hash_size-1 */ + + this.hash_shift = 0; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + this.block_start = 0; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + this.match_length = 0; /* length of best match */ + this.prev_match = 0; /* previous match */ + this.match_available = 0; /* set if previous match exists */ + this.strstart = 0; /* start of string to insert */ + this.match_start = 0; /* start of matching string */ + this.lookahead = 0; /* number of valid bytes ahead in window */ + + this.prev_length = 0; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + this.max_chain_length = 0; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + this.max_lazy_match = 0; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ + // That's alias to max_lazy_match, don't use directly + //this.max_insert_length = 0; + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + this.level = 0; /* compression level (1..9) */ + this.strategy = 0; /* favor or force Huffman coding*/ + + this.good_match = 0; + /* Use a faster search when the previous match is longer than this */ + + this.nice_match = 0; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + + /* Didn't use ct_data typedef below to suppress compiler warning */ + + // struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + // struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + // Use flat array of DOUBLE size, with interleaved fata, + // because JS does not support effective + this.dyn_ltree = new utils.Buf16(HEAP_SIZE * 2); + this.dyn_dtree = new utils.Buf16((2 * D_CODES + 1) * 2); + this.bl_tree = new utils.Buf16((2 * BL_CODES + 1) * 2); + zero(this.dyn_ltree); + zero(this.dyn_dtree); + zero(this.bl_tree); + + this.l_desc = null; /* desc. for literal tree */ + this.d_desc = null; /* desc. for distance tree */ + this.bl_desc = null; /* desc. for bit length tree */ + + //ush bl_count[MAX_BITS+1]; + this.bl_count = new utils.Buf16(MAX_BITS + 1); + /* number of codes at each bit length for an optimal tree */ + + //int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + this.heap = new utils.Buf16(2 * L_CODES + 1); /* heap used to build the Huffman trees */ + zero(this.heap); + + this.heap_len = 0; /* number of elements in the heap */ + this.heap_max = 0; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + this.depth = new utils.Buf16(2 * L_CODES + 1); //uch depth[2*L_CODES+1]; + zero(this.depth); + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + this.l_buf = 0; /* buffer index for literals or lengths */ + + this.lit_bufsize = 0; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + this.last_lit = 0; /* running index in l_buf */ + + this.d_buf = 0; + /* Buffer index for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + this.opt_len = 0; /* bit length of current block with optimal trees */ + this.static_len = 0; /* bit length of current block with static trees */ + this.matches = 0; /* number of string matches in current block */ + this.insert = 0; /* bytes at end of window left to insert */ + + + this.bi_buf = 0; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + this.bi_valid = 0; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + + // Used for window memory init. We safely ignore it for JS. That makes + // sense only for pointers and memory check tools. + //this.high_water = 0; + /* High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when + * longest match routines access bytes past the input. This is then + * updated to the new high water mark. + */ +} + + +function deflateResetKeep(strm) { + var s; + + if (!strm || !strm.state) { + return err(strm, Z_STREAM_ERROR); + } + + strm.total_in = strm.total_out = 0; + strm.data_type = Z_UNKNOWN; + + s = strm.state; + s.pending = 0; + s.pending_out = 0; + + if (s.wrap < 0) { + s.wrap = -s.wrap; + /* was made negative by deflate(..., Z_FINISH); */ + } + s.status = (s.wrap ? INIT_STATE : BUSY_STATE); + strm.adler = (s.wrap === 2) ? + 0 // crc32(0, Z_NULL, 0) + : + 1; // adler32(0, Z_NULL, 0) + s.last_flush = Z_NO_FLUSH; + trees._tr_init(s); + return Z_OK; +} + + +function deflateReset(strm) { + var ret = deflateResetKeep(strm); + if (ret === Z_OK) { + lm_init(strm.state); + } + return ret; +} + + +function deflateSetHeader(strm, head) { + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + if (strm.state.wrap !== 2) { return Z_STREAM_ERROR; } + strm.state.gzhead = head; + return Z_OK; +} + + +function deflateInit2(strm, level, method, windowBits, memLevel, strategy) { + if (!strm) { // === Z_NULL + return Z_STREAM_ERROR; + } + var wrap = 1; + + if (level === Z_DEFAULT_COMPRESSION) { + level = 6; + } + + if (windowBits < 0) { /* suppress zlib wrapper */ + wrap = 0; + windowBits = -windowBits; + } + + else if (windowBits > 15) { + wrap = 2; /* write gzip wrapper instead */ + windowBits -= 16; + } + + + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) { + return err(strm, Z_STREAM_ERROR); + } + + + if (windowBits === 8) { + windowBits = 9; + } + /* until 256-byte window bug fixed */ + + var s = new DeflateState(); + + strm.state = s; + s.strm = strm; + + s.wrap = wrap; + s.gzhead = null; + s.w_bits = windowBits; + s.w_size = 1 << s.w_bits; + s.w_mask = s.w_size - 1; + + s.hash_bits = memLevel + 7; + s.hash_size = 1 << s.hash_bits; + s.hash_mask = s.hash_size - 1; + s.hash_shift = ~~((s.hash_bits + MIN_MATCH - 1) / MIN_MATCH); + + s.window = new utils.Buf8(s.w_size * 2); + s.head = new utils.Buf16(s.hash_size); + s.prev = new utils.Buf16(s.w_size); + + // Don't need mem init magic for JS. + //s.high_water = 0; /* nothing written to s->window yet */ + + s.lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + s.pending_buf_size = s.lit_bufsize * 4; + + //overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); + //s->pending_buf = (uchf *) overlay; + s.pending_buf = new utils.Buf8(s.pending_buf_size); + + // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`) + //s->d_buf = overlay + s->lit_bufsize/sizeof(ush); + s.d_buf = 1 * s.lit_bufsize; + + //s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + s.l_buf = (1 + 2) * s.lit_bufsize; + + s.level = level; + s.strategy = strategy; + s.method = method; + + return deflateReset(strm); +} + +function deflateInit(strm, level) { + return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY); +} + + +function deflate(strm, flush) { + var old_flush, s; + var beg, val; // for gzip header write only + + if (!strm || !strm.state || + flush > Z_BLOCK || flush < 0) { + return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR; + } + + s = strm.state; + + if (!strm.output || + (!strm.input && strm.avail_in !== 0) || + (s.status === FINISH_STATE && flush !== Z_FINISH)) { + return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR : Z_STREAM_ERROR); + } + + s.strm = strm; /* just in case */ + old_flush = s.last_flush; + s.last_flush = flush; + + /* Write the header */ + if (s.status === INIT_STATE) { + + if (s.wrap === 2) { // GZIP header + strm.adler = 0; //crc32(0L, Z_NULL, 0); + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (!s.gzhead) { // s->gzhead == Z_NULL + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, OS_CODE); + s.status = BUSY_STATE; + } + else { + put_byte(s, (s.gzhead.text ? 1 : 0) + + (s.gzhead.hcrc ? 2 : 0) + + (!s.gzhead.extra ? 0 : 4) + + (!s.gzhead.name ? 0 : 8) + + (!s.gzhead.comment ? 0 : 16) + ); + put_byte(s, s.gzhead.time & 0xff); + put_byte(s, (s.gzhead.time >> 8) & 0xff); + put_byte(s, (s.gzhead.time >> 16) & 0xff); + put_byte(s, (s.gzhead.time >> 24) & 0xff); + put_byte(s, s.level === 9 ? 2 : + (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? + 4 : 0)); + put_byte(s, s.gzhead.os & 0xff); + if (s.gzhead.extra && s.gzhead.extra.length) { + put_byte(s, s.gzhead.extra.length & 0xff); + put_byte(s, (s.gzhead.extra.length >> 8) & 0xff); + } + if (s.gzhead.hcrc) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending, 0); + } + s.gzindex = 0; + s.status = EXTRA_STATE; + } + } + else // DEFLATE header + { + var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8; + var level_flags = -1; + + if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) { + level_flags = 0; + } else if (s.level < 6) { + level_flags = 1; + } else if (s.level === 6) { + level_flags = 2; + } else { + level_flags = 3; + } + header |= (level_flags << 6); + if (s.strstart !== 0) { header |= PRESET_DICT; } + header += 31 - (header % 31); + + s.status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s.strstart !== 0) { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + strm.adler = 1; // adler32(0L, Z_NULL, 0); + } + } + +//#ifdef GZIP + if (s.status === EXTRA_STATE) { + if (s.gzhead.extra/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + + while (s.gzindex < (s.gzhead.extra.length & 0xffff)) { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + break; + } + } + put_byte(s, s.gzhead.extra[s.gzindex] & 0xff); + s.gzindex++; + } + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (s.gzindex === s.gzhead.extra.length) { + s.gzindex = 0; + s.status = NAME_STATE; + } + } + else { + s.status = NAME_STATE; + } + } + if (s.status === NAME_STATE) { + if (s.gzhead.name/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + //int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.name.length) { + val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.gzindex = 0; + s.status = COMMENT_STATE; + } + } + else { + s.status = COMMENT_STATE; + } + } + if (s.status === COMMENT_STATE) { + if (s.gzhead.comment/* != Z_NULL*/) { + beg = s.pending; /* start of bytes to update crc */ + //int val; + + do { + if (s.pending === s.pending_buf_size) { + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + flush_pending(strm); + beg = s.pending; + if (s.pending === s.pending_buf_size) { + val = 1; + break; + } + } + // JS specific: little magic to add zero terminator to end of string + if (s.gzindex < s.gzhead.comment.length) { + val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff; + } else { + val = 0; + } + put_byte(s, val); + } while (val !== 0); + + if (s.gzhead.hcrc && s.pending > beg) { + strm.adler = crc32(strm.adler, s.pending_buf, s.pending - beg, beg); + } + if (val === 0) { + s.status = HCRC_STATE; + } + } + else { + s.status = HCRC_STATE; + } + } + if (s.status === HCRC_STATE) { + if (s.gzhead.hcrc) { + if (s.pending + 2 > s.pending_buf_size) { + flush_pending(strm); + } + if (s.pending + 2 <= s.pending_buf_size) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + strm.adler = 0; //crc32(0L, Z_NULL, 0); + s.status = BUSY_STATE; + } + } + else { + s.status = BUSY_STATE; + } + } +//#endif + + /* Flush as much pending output as possible */ + if (s.pending !== 0) { + flush_pending(strm); + if (strm.avail_out === 0) { + /* Since avail_out is 0, deflate will be called again with + * more output space, but possibly with both pending and + * avail_in equal to zero. There won't be anything to do, + * but this is not an error situation so make sure we + * return OK instead of BUF_ERROR at next call of deflate: + */ + s.last_flush = -1; + return Z_OK; + } + + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && + flush !== Z_FINISH) { + return err(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s.status === FINISH_STATE && strm.avail_in !== 0) { + return err(strm, Z_BUF_ERROR); + } + + /* Start a new block or continue the current one. + */ + if (strm.avail_in !== 0 || s.lookahead !== 0 || + (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) { + var bstate = (s.strategy === Z_HUFFMAN_ONLY) ? deflate_huff(s, flush) : + (s.strategy === Z_RLE ? deflate_rle(s, flush) : + configuration_table[s.level].func(s, flush)); + + if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) { + s.status = FINISH_STATE; + } + if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) { + if (strm.avail_out === 0) { + s.last_flush = -1; + /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* If flush != Z_NO_FLUSH && avail_out == 0, the next call + * of deflate should use the same flush parameter to make sure + * that the flush is complete. So we don't have to output an + * empty block here, this will be done at next call. This also + * ensures that for a very small output buffer, we emit at most + * one empty block. + */ + } + if (bstate === BS_BLOCK_DONE) { + if (flush === Z_PARTIAL_FLUSH) { + trees._tr_align(s); + } + else if (flush !== Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + + trees._tr_stored_block(s, 0, 0, false); + /* For a full flush, this empty block will be recognized + * as a special marker by inflate_sync(). + */ + if (flush === Z_FULL_FLUSH) { + /*** CLEAR_HASH(s); ***/ /* forget history */ + zero(s.head); // Fill with NIL (= 0); + + if (s.lookahead === 0) { + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + } + } + flush_pending(strm); + if (strm.avail_out === 0) { + s.last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + //Assert(strm->avail_out > 0, "bug2"); + //if (strm.avail_out <= 0) { throw new Error("bug2");} + + if (flush !== Z_FINISH) { return Z_OK; } + if (s.wrap <= 0) { return Z_STREAM_END; } + + /* Write the trailer */ + if (s.wrap === 2) { + put_byte(s, strm.adler & 0xff); + put_byte(s, (strm.adler >> 8) & 0xff); + put_byte(s, (strm.adler >> 16) & 0xff); + put_byte(s, (strm.adler >> 24) & 0xff); + put_byte(s, strm.total_in & 0xff); + put_byte(s, (strm.total_in >> 8) & 0xff); + put_byte(s, (strm.total_in >> 16) & 0xff); + put_byte(s, (strm.total_in >> 24) & 0xff); + } + else + { + putShortMSB(s, strm.adler >>> 16); + putShortMSB(s, strm.adler & 0xffff); + } + + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again + * to flush the rest. + */ + if (s.wrap > 0) { s.wrap = -s.wrap; } + /* write the trailer only once! */ + return s.pending !== 0 ? Z_OK : Z_STREAM_END; +} + +function deflateEnd(strm) { + var status; + + if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) { + return Z_STREAM_ERROR; + } + + status = strm.state.status; + if (status !== INIT_STATE && + status !== EXTRA_STATE && + status !== NAME_STATE && + status !== COMMENT_STATE && + status !== HCRC_STATE && + status !== BUSY_STATE && + status !== FINISH_STATE + ) { + return err(strm, Z_STREAM_ERROR); + } + + strm.state = null; + + return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK; +} + + +/* ========================================================================= + * Initializes the compression dictionary from the given byte + * sequence without producing any compressed output. + */ +function deflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + + var s; + var str, n; + var wrap; + var avail; + var next; + var input; + var tmpDict; + + if (!strm/*== Z_NULL*/ || !strm.state/*== Z_NULL*/) { + return Z_STREAM_ERROR; + } + + s = strm.state; + wrap = s.wrap; + + if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) { + return Z_STREAM_ERROR; + } + + /* when using zlib wrappers, compute Adler-32 for provided dictionary */ + if (wrap === 1) { + /* adler32(strm->adler, dictionary, dictLength); */ + strm.adler = adler32(strm.adler, dictionary, dictLength, 0); + } + + s.wrap = 0; /* avoid computing Adler-32 in read_buf */ + + /* if dictionary would fill window, just replace the history */ + if (dictLength >= s.w_size) { + if (wrap === 0) { /* already empty otherwise */ + /*** CLEAR_HASH(s); ***/ + zero(s.head); // Fill with NIL (= 0); + s.strstart = 0; + s.block_start = 0; + s.insert = 0; + } + /* use the tail */ + // dictionary = dictionary.slice(dictLength - s.w_size); + tmpDict = new utils.Buf8(s.w_size); + utils.arraySet(tmpDict, dictionary, dictLength - s.w_size, s.w_size, 0); + dictionary = tmpDict; + dictLength = s.w_size; + } + /* insert dictionary into window and hash */ + avail = strm.avail_in; + next = strm.next_in; + input = strm.input; + strm.avail_in = dictLength; + strm.next_in = 0; + strm.input = dictionary; + fill_window(s); + while (s.lookahead >= MIN_MATCH) { + str = s.strstart; + n = s.lookahead - (MIN_MATCH - 1); + do { + /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */ + s.ins_h = ((s.ins_h << s.hash_shift) ^ s.window[str + MIN_MATCH - 1]) & s.hash_mask; + + s.prev[str & s.w_mask] = s.head[s.ins_h]; + + s.head[s.ins_h] = str; + str++; + } while (--n); + s.strstart = str; + s.lookahead = MIN_MATCH - 1; + fill_window(s); + } + s.strstart += s.lookahead; + s.block_start = s.strstart; + s.insert = s.lookahead; + s.lookahead = 0; + s.match_length = s.prev_length = MIN_MATCH - 1; + s.match_available = 0; + strm.next_in = next; + strm.input = input; + strm.avail_in = avail; + s.wrap = wrap; + return Z_OK; +} + + +exports.deflateInit = deflateInit; +exports.deflateInit2 = deflateInit2; +exports.deflateReset = deflateReset; +exports.deflateResetKeep = deflateResetKeep; +exports.deflateSetHeader = deflateSetHeader; +exports.deflate = deflate; +exports.deflateEnd = deflateEnd; +exports.deflateSetDictionary = deflateSetDictionary; +exports.deflateInfo = 'pako deflate (from Nodeca project)'; + +/* Not implemented +exports.deflateBound = deflateBound; +exports.deflateCopy = deflateCopy; +exports.deflateParams = deflateParams; +exports.deflatePending = deflatePending; +exports.deflatePrime = deflatePrime; +exports.deflateTune = deflateTune; +*/ + + +/***/ }, + +/***/ 6395 +(module) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +// See state defs from inflate.js +var BAD = 30; /* got a data error -- remain here until reset */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ + +/* + Decode literal, length, and distance codes and write out the resulting + literal and match bytes until either not enough input or output is + available, an end-of-block is encountered, or a data error is encountered. + When large enough input and output buffers are supplied to inflate(), for + example, a 16K input buffer and a 64K output buffer, more than 95% of the + inflate execution time is spent in this routine. + + Entry assumptions: + + state.mode === LEN + strm.avail_in >= 6 + strm.avail_out >= 258 + start >= strm.avail_out + state.bits < 8 + + On return, state.mode is one of: + + LEN -- ran out of enough output space or enough available input + TYPE -- reached end of block code, inflate() to interpret next block + BAD -- error in block data + + Notes: + + - The maximum input bits used by a length/distance pair is 15 bits for the + length code, 5 bits for the length extra, 15 bits for the distance code, + and 13 bits for the distance extra. This totals 48 bits, or six bytes. + Therefore if strm.avail_in >= 6, then there is enough input to avoid + checking for available input while decoding. + + - The maximum bytes that a single length/distance pair can output is 258 + bytes, which is the maximum length that can be coded. inflate_fast() + requires strm.avail_out >= 258 for each loop to avoid checking for + output space. + */ +module.exports = function inflate_fast(strm, start) { + var state; + var _in; /* local strm.input */ + var last; /* have enough input while in < last */ + var _out; /* local strm.output */ + var beg; /* inflate()'s initial strm.output */ + var end; /* while out < end, enough space available */ +//#ifdef INFLATE_STRICT + var dmax; /* maximum distance from zlib header */ +//#endif + var wsize; /* window size or zero if not using window */ + var whave; /* valid bytes in the window */ + var wnext; /* window write index */ + // Use `s_window` instead `window`, avoid conflict with instrumentation tools + var s_window; /* allocated sliding window, if wsize != 0 */ + var hold; /* local strm.hold */ + var bits; /* local strm.bits */ + var lcode; /* local strm.lencode */ + var dcode; /* local strm.distcode */ + var lmask; /* mask for first level of length codes */ + var dmask; /* mask for first level of distance codes */ + var here; /* retrieved table entry */ + var op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + var len; /* match length, unused bytes */ + var dist; /* match distance */ + var from; /* where to copy match from */ + var from_source; + + + var input, output; // JS specific, because we have no pointers + + /* copy state to local variables */ + state = strm.state; + //here = state.here; + _in = strm.next_in; + input = strm.input; + last = _in + (strm.avail_in - 5); + _out = strm.next_out; + output = strm.output; + beg = _out - (start - strm.avail_out); + end = _out + (strm.avail_out - 257); +//#ifdef INFLATE_STRICT + dmax = state.dmax; +//#endif + wsize = state.wsize; + whave = state.whave; + wnext = state.wnext; + s_window = state.window; + hold = state.hold; + bits = state.bits; + lcode = state.lencode; + dcode = state.distcode; + lmask = (1 << state.lenbits) - 1; + dmask = (1 << state.distbits) - 1; + + + /* decode literals and length/distances until end-of-block or not enough + input data or output space */ + + top: + do { + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + + here = lcode[hold & lmask]; + + dolen: + for (;;) { // Goto emulation + op = here >>> 24/*here.bits*/; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/*here.op*/; + if (op === 0) { /* literal */ + //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + output[_out++] = here & 0xffff/*here.val*/; + } + else if (op & 16) { /* length base */ + len = here & 0xffff/*here.val*/; + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + len += hold & ((1 << op) - 1); + hold >>>= op; + bits -= op; + } + //Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += input[_in++] << bits; + bits += 8; + hold += input[_in++] << bits; + bits += 8; + } + here = dcode[hold & dmask]; + + dodist: + for (;;) { // goto emulation + op = here >>> 24/*here.bits*/; + hold >>>= op; + bits -= op; + op = (here >>> 16) & 0xff/*here.op*/; + + if (op & 16) { /* distance base */ + dist = here & 0xffff/*here.val*/; + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + if (bits < op) { + hold += input[_in++] << bits; + bits += 8; + } + } + dist += hold & ((1 << op) - 1); +//#ifdef INFLATE_STRICT + if (dist > dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } +//#endif + hold >>>= op; + bits -= op; + //Tracevv((stderr, "inflate: distance %u\n", dist)); + op = _out - beg; /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break top; + } + +// (!) This block is disabled in zlib defaults, +// don't enable it for binary compatibility +//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// if (len <= op - whave) { +// do { +// output[_out++] = 0; +// } while (--len); +// continue top; +// } +// len -= op - whave; +// do { +// output[_out++] = 0; +// } while (--op > whave); +// if (op === 0) { +// from = _out - dist; +// do { +// output[_out++] = output[from++]; +// } while (--len); +// continue top; +// } +//#endif + } + from = 0; // window index + from_source = s_window; + if (wnext === 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + else if (wnext < op) { /* wrap around window */ + from += wsize + wnext - op; + op -= wnext; + if (op < len) { /* some from end of window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = 0; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + } + else { /* contiguous in window */ + from += wnext - op; + if (op < len) { /* some from window */ + len -= op; + do { + output[_out++] = s_window[from++]; + } while (--op); + from = _out - dist; /* rest from output */ + from_source = output; + } + } + while (len > 2) { + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + output[_out++] = from_source[from++]; + len -= 3; + } + if (len) { + output[_out++] = from_source[from++]; + if (len > 1) { + output[_out++] = from_source[from++]; + } + } + } + else { + from = _out - dist; /* copy direct from output */ + do { /* minimum length is three */ + output[_out++] = output[from++]; + output[_out++] = output[from++]; + output[_out++] = output[from++]; + len -= 3; + } while (len > 2); + if (len) { + output[_out++] = output[from++]; + if (len > 1) { + output[_out++] = output[from++]; + } + } + } + } + else if ((op & 64) === 0) { /* 2nd level distance code */ + here = dcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; + continue dodist; + } + else { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } + else if ((op & 64) === 0) { /* 2nd level length code */ + here = lcode[(here & 0xffff)/*here.val*/ + (hold & ((1 << op) - 1))]; + continue dolen; + } + else if (op & 32) { /* end-of-block */ + //Tracevv((stderr, "inflate: end of block\n")); + state.mode = TYPE; + break top; + } + else { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break top; + } + + break; // need to emulate goto via "continue" + } + } while (_in < last && _out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + _in -= len; + bits -= len << 3; + hold &= (1 << bits) - 1; + + /* update state and return */ + strm.next_in = _in; + strm.next_out = _out; + strm.avail_in = (_in < last ? 5 + (last - _in) : 5 - (_in - last)); + strm.avail_out = (_out < end ? 257 + (end - _out) : 257 - (_out - end)); + state.hold = hold; + state.bits = bits; + return; +}; + + +/***/ }, + +/***/ 2269 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +var utils = __webpack_require__(2519); +var adler32 = __webpack_require__(6911); +var crc32 = __webpack_require__(9049); +var inflate_fast = __webpack_require__(6395); +var inflate_table = __webpack_require__(2920); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +/* Allowed flush values; see deflate() and inflate() below for details */ +//var Z_NO_FLUSH = 0; +//var Z_PARTIAL_FLUSH = 1; +//var Z_SYNC_FLUSH = 2; +//var Z_FULL_FLUSH = 3; +var Z_FINISH = 4; +var Z_BLOCK = 5; +var Z_TREES = 6; + + +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ +var Z_OK = 0; +var Z_STREAM_END = 1; +var Z_NEED_DICT = 2; +//var Z_ERRNO = -1; +var Z_STREAM_ERROR = -2; +var Z_DATA_ERROR = -3; +var Z_MEM_ERROR = -4; +var Z_BUF_ERROR = -5; +//var Z_VERSION_ERROR = -6; + +/* The deflate compression method */ +var Z_DEFLATED = 8; + + +/* STATES ====================================================================*/ +/* ===========================================================================*/ + + +var HEAD = 1; /* i: waiting for magic header */ +var FLAGS = 2; /* i: waiting for method and flags (gzip) */ +var TIME = 3; /* i: waiting for modification time (gzip) */ +var OS = 4; /* i: waiting for extra flags and operating system (gzip) */ +var EXLEN = 5; /* i: waiting for extra length (gzip) */ +var EXTRA = 6; /* i: waiting for extra bytes (gzip) */ +var NAME = 7; /* i: waiting for end of file name (gzip) */ +var COMMENT = 8; /* i: waiting for end of comment (gzip) */ +var HCRC = 9; /* i: waiting for header crc (gzip) */ +var DICTID = 10; /* i: waiting for dictionary check value */ +var DICT = 11; /* waiting for inflateSetDictionary() call */ +var TYPE = 12; /* i: waiting for type bits, including last-flag bit */ +var TYPEDO = 13; /* i: same, but skip check to exit inflate on new block */ +var STORED = 14; /* i: waiting for stored size (length and complement) */ +var COPY_ = 15; /* i/o: same as COPY below, but only first time in */ +var COPY = 16; /* i/o: waiting for input or output to copy stored block */ +var TABLE = 17; /* i: waiting for dynamic block table lengths */ +var LENLENS = 18; /* i: waiting for code length code lengths */ +var CODELENS = 19; /* i: waiting for length/lit and distance code lengths */ +var LEN_ = 20; /* i: same as LEN below, but only first time in */ +var LEN = 21; /* i: waiting for length/lit/eob code */ +var LENEXT = 22; /* i: waiting for length extra bits */ +var DIST = 23; /* i: waiting for distance code */ +var DISTEXT = 24; /* i: waiting for distance extra bits */ +var MATCH = 25; /* o: waiting for output space to copy string */ +var LIT = 26; /* o: waiting for output space to write literal */ +var CHECK = 27; /* i: waiting for 32-bit check value */ +var LENGTH = 28; /* i: waiting for 32-bit length (gzip) */ +var DONE = 29; /* finished check, done -- remain here until reset */ +var BAD = 30; /* got a data error -- remain here until reset */ +var MEM = 31; /* got an inflate() memory error -- remain here until reset */ +var SYNC = 32; /* looking for synchronization bytes to restart inflate() */ + +/* ===========================================================================*/ + + + +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var MAX_WBITS = 15; +/* 32K LZ77 window */ +var DEF_WBITS = MAX_WBITS; + + +function zswap32(q) { + return (((q >>> 24) & 0xff) + + ((q >>> 8) & 0xff00) + + ((q & 0xff00) << 8) + + ((q & 0xff) << 24)); +} + + +function InflateState() { + this.mode = 0; /* current inflate mode */ + this.last = false; /* true if processing last block */ + this.wrap = 0; /* bit 0 true for zlib, bit 1 true for gzip */ + this.havedict = false; /* true if dictionary provided */ + this.flags = 0; /* gzip header method and flags (0 if zlib) */ + this.dmax = 0; /* zlib header max distance (INFLATE_STRICT) */ + this.check = 0; /* protected copy of check value */ + this.total = 0; /* protected copy of output count */ + // TODO: may be {} + this.head = null; /* where to save gzip header information */ + + /* sliding window */ + this.wbits = 0; /* log base 2 of requested window size */ + this.wsize = 0; /* window size or zero if not using window */ + this.whave = 0; /* valid bytes in the window */ + this.wnext = 0; /* window write index */ + this.window = null; /* allocated sliding window, if needed */ + + /* bit accumulator */ + this.hold = 0; /* input bit accumulator */ + this.bits = 0; /* number of bits in "in" */ + + /* for string and stored block copying */ + this.length = 0; /* literal or length of data to copy */ + this.offset = 0; /* distance back to copy string from */ + + /* for table and code decoding */ + this.extra = 0; /* extra bits needed */ + + /* fixed and dynamic code tables */ + this.lencode = null; /* starting table for length/literal codes */ + this.distcode = null; /* starting table for distance codes */ + this.lenbits = 0; /* index bits for lencode */ + this.distbits = 0; /* index bits for distcode */ + + /* dynamic table building */ + this.ncode = 0; /* number of code length code lengths */ + this.nlen = 0; /* number of length code lengths */ + this.ndist = 0; /* number of distance code lengths */ + this.have = 0; /* number of code lengths in lens[] */ + this.next = null; /* next available space in codes[] */ + + this.lens = new utils.Buf16(320); /* temporary storage for code lengths */ + this.work = new utils.Buf16(288); /* work area for code table building */ + + /* + because we don't have pointers in js, we use lencode and distcode directly + as buffers so we don't need codes + */ + //this.codes = new utils.Buf32(ENOUGH); /* space for code tables */ + this.lendyn = null; /* dynamic table for length/literal codes (JS specific) */ + this.distdyn = null; /* dynamic table for distance codes (JS specific) */ + this.sane = 0; /* if false, allow invalid distance too far */ + this.back = 0; /* bits back of last unprocessed length/lit */ + this.was = 0; /* initial length of match */ +} + +function inflateResetKeep(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + strm.total_in = strm.total_out = state.total = 0; + strm.msg = ''; /*Z_NULL*/ + if (state.wrap) { /* to support ill-conceived Java test suite */ + strm.adler = state.wrap & 1; + } + state.mode = HEAD; + state.last = 0; + state.havedict = 0; + state.dmax = 32768; + state.head = null/*Z_NULL*/; + state.hold = 0; + state.bits = 0; + //state.lencode = state.distcode = state.next = state.codes; + state.lencode = state.lendyn = new utils.Buf32(ENOUGH_LENS); + state.distcode = state.distdyn = new utils.Buf32(ENOUGH_DISTS); + + state.sane = 1; + state.back = -1; + //Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +function inflateReset(strm) { + var state; + + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + state.wsize = 0; + state.whave = 0; + state.wnext = 0; + return inflateResetKeep(strm); + +} + +function inflateReset2(strm, windowBits) { + var wrap; + var state; + + /* get the state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + + /* extract wrap request from windowBits parameter */ + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } + else { + wrap = (windowBits >> 4) + 1; + if (windowBits < 48) { + windowBits &= 15; + } + } + + /* set number of window bits, free window if different */ + if (windowBits && (windowBits < 8 || windowBits > 15)) { + return Z_STREAM_ERROR; + } + if (state.window !== null && state.wbits !== windowBits) { + state.window = null; + } + + /* update state and reset the rest of it */ + state.wrap = wrap; + state.wbits = windowBits; + return inflateReset(strm); +} + +function inflateInit2(strm, windowBits) { + var ret; + var state; + + if (!strm) { return Z_STREAM_ERROR; } + //strm.msg = Z_NULL; /* in case we return an error */ + + state = new InflateState(); + + //if (state === Z_NULL) return Z_MEM_ERROR; + //Tracev((stderr, "inflate: allocated\n")); + strm.state = state; + state.window = null/*Z_NULL*/; + ret = inflateReset2(strm, windowBits); + if (ret !== Z_OK) { + strm.state = null/*Z_NULL*/; + } + return ret; +} + +function inflateInit(strm) { + return inflateInit2(strm, DEF_WBITS); +} + + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +var virgin = true; + +var lenfix, distfix; // We have no pointers in JS, so keep tables separate + +function fixedtables(state) { + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + var sym; + + lenfix = new utils.Buf32(512); + distfix = new utils.Buf32(32); + + /* literal/length table */ + sym = 0; + while (sym < 144) { state.lens[sym++] = 8; } + while (sym < 256) { state.lens[sym++] = 9; } + while (sym < 280) { state.lens[sym++] = 7; } + while (sym < 288) { state.lens[sym++] = 8; } + + inflate_table(LENS, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 }); + + /* distance table */ + sym = 0; + while (sym < 32) { state.lens[sym++] = 5; } + + inflate_table(DISTS, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 }); + + /* do this just once */ + virgin = false; + } + + state.lencode = lenfix; + state.lenbits = 9; + state.distcode = distfix; + state.distbits = 5; +} + + +/* + Update the window with the last wsize (normally 32K) bytes written before + returning. If window does not exist yet, create it. This is only called + when a window is already in use, or when output has been written during this + inflate call, but the end of the deflate stream has not been reached yet. + It is also called to create a window for dictionary data when a dictionary + is loaded. + + Providing output buffers larger than 32K to inflate() should provide a speed + advantage, since only the last 32K of output is copied to the sliding window + upon return from inflate(), and since all distances after the first 32K of + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +function updatewindow(strm, src, end, copy) { + var dist; + var state = strm.state; + + /* if it hasn't been done already, allocate space for the window */ + if (state.window === null) { + state.wsize = 1 << state.wbits; + state.wnext = 0; + state.whave = 0; + + state.window = new utils.Buf8(state.wsize); + } + + /* copy state->wsize or less output bytes into the circular window */ + if (copy >= state.wsize) { + utils.arraySet(state.window, src, end - state.wsize, state.wsize, 0); + state.wnext = 0; + state.whave = state.wsize; + } + else { + dist = state.wsize - state.wnext; + if (dist > copy) { + dist = copy; + } + //zmemcpy(state->window + state->wnext, end - copy, dist); + utils.arraySet(state.window, src, end - copy, dist, state.wnext); + copy -= dist; + if (copy) { + //zmemcpy(state->window, end - copy, copy); + utils.arraySet(state.window, src, end - copy, copy, 0); + state.wnext = copy; + state.whave = state.wsize; + } + else { + state.wnext += dist; + if (state.wnext === state.wsize) { state.wnext = 0; } + if (state.whave < state.wsize) { state.whave += dist; } + } + } + return 0; +} + +function inflate(strm, flush) { + var state; + var input, output; // input/output buffers + var next; /* next input INDEX */ + var put; /* next output INDEX */ + var have, left; /* available input and output */ + var hold; /* bit buffer */ + var bits; /* bits in bit buffer */ + var _in, _out; /* save starting available input and output */ + var copy; /* number of stored or match bytes to copy */ + var from; /* where to copy match bytes from */ + var from_source; + var here = 0; /* current decoding table entry */ + var here_bits, here_op, here_val; // paked "here" denormalized (JS specific) + //var last; /* parent table entry */ + var last_bits, last_op, last_val; // paked "last" denormalized (JS specific) + var len; /* length to copy for repeats, bits to drop */ + var ret; /* return code */ + var hbuf = new utils.Buf8(4); /* buffer for gzip header crc calculation */ + var opts; + + var n; // temporary var for NEED_BITS + + var order = /* permutation of code lengths */ + [ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 ]; + + + if (!strm || !strm.state || !strm.output || + (!strm.input && strm.avail_in !== 0)) { + return Z_STREAM_ERROR; + } + + state = strm.state; + if (state.mode === TYPE) { state.mode = TYPEDO; } /* skip check */ + + + //--- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + //--- + + _in = have; + _out = left; + ret = Z_OK; + + inf_leave: // goto emulation + for (;;) { + switch (state.mode) { + case HEAD: + if (state.wrap === 0) { + state.mode = TYPEDO; + break; + } + //=== NEEDBITS(16); + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if ((state.wrap & 2) && hold === 0x8b1f) { /* gzip header */ + state.check = 0/*crc32(0L, Z_NULL, 0)*/; + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = FLAGS; + break; + } + state.flags = 0; /* expect zlib header */ + if (state.head) { + state.head.done = false; + } + if (!(state.wrap & 1) || /* check if zlib header allowed */ + (((hold & 0xff)/*BITS(8)*/ << 8) + (hold >> 8)) % 31) { + strm.msg = 'incorrect header check'; + state.mode = BAD; + break; + } + if ((hold & 0x0f)/*BITS(4)*/ !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + //--- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + //---// + len = (hold & 0x0f)/*BITS(4)*/ + 8; + if (state.wbits === 0) { + state.wbits = len; + } + else if (len > state.wbits) { + strm.msg = 'invalid window size'; + state.mode = BAD; + break; + } + state.dmax = 1 << len; + //Tracev((stderr, "inflate: zlib header ok\n")); + strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; + state.mode = hold & 0x200 ? DICTID : TYPE; + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + break; + case FLAGS: + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.flags = hold; + if ((state.flags & 0xff) !== Z_DEFLATED) { + strm.msg = 'unknown compression method'; + state.mode = BAD; + break; + } + if (state.flags & 0xe000) { + strm.msg = 'unknown header flags set'; + state.mode = BAD; + break; + } + if (state.head) { + state.head.text = ((hold >> 8) & 1); + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = TIME; + /* falls through */ + case TIME: + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (state.head) { + state.head.time = hold; + } + if (state.flags & 0x0200) { + //=== CRC4(state.check, hold) + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + hbuf[2] = (hold >>> 16) & 0xff; + hbuf[3] = (hold >>> 24) & 0xff; + state.check = crc32(state.check, hbuf, 4, 0); + //=== + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = OS; + /* falls through */ + case OS: + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (state.head) { + state.head.xflags = (hold & 0xff); + state.head.os = (hold >> 8); + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = EXLEN; + /* falls through */ + case EXLEN: + if (state.flags & 0x0400) { + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.length = hold; + if (state.head) { + state.head.extra_len = hold; + } + if (state.flags & 0x0200) { + //=== CRC2(state.check, hold); + hbuf[0] = hold & 0xff; + hbuf[1] = (hold >>> 8) & 0xff; + state.check = crc32(state.check, hbuf, 2, 0); + //===// + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + } + else if (state.head) { + state.head.extra = null/*Z_NULL*/; + } + state.mode = EXTRA; + /* falls through */ + case EXTRA: + if (state.flags & 0x0400) { + copy = state.length; + if (copy > have) { copy = have; } + if (copy) { + if (state.head) { + len = state.head.extra_len - state.length; + if (!state.head.extra) { + // Use untyped array for more convenient processing later + state.head.extra = new Array(state.head.extra_len); + } + utils.arraySet( + state.head.extra, + input, + next, + // extra field is limited to 65536 bytes + // - no need for additional size check + copy, + /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/ + len + ); + //zmemcpy(state.head.extra + len, next, + // len + copy > state.head.extra_max ? + // state.head.extra_max - len : copy); + } + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + state.length -= copy; + } + if (state.length) { break inf_leave; } + } + state.length = 0; + state.mode = NAME; + /* falls through */ + case NAME: + if (state.flags & 0x0800) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + // TODO: 2 or 1 bytes? + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /*state.head.name_max*/)) { + state.head.name += String.fromCharCode(len); + } + } while (len && copy < have); + + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.name = null; + } + state.length = 0; + state.mode = COMMENT; + /* falls through */ + case COMMENT: + if (state.flags & 0x1000) { + if (have === 0) { break inf_leave; } + copy = 0; + do { + len = input[next + copy++]; + /* use constant limit because in js we should not preallocate memory */ + if (state.head && len && + (state.length < 65536 /*state.head.comm_max*/)) { + state.head.comment += String.fromCharCode(len); + } + } while (len && copy < have); + if (state.flags & 0x0200) { + state.check = crc32(state.check, input, copy, next); + } + have -= copy; + next += copy; + if (len) { break inf_leave; } + } + else if (state.head) { + state.head.comment = null; + } + state.mode = HCRC; + /* falls through */ + case HCRC: + if (state.flags & 0x0200) { + //=== NEEDBITS(16); */ + while (bits < 16) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (hold !== (state.check & 0xffff)) { + strm.msg = 'header crc mismatch'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + } + if (state.head) { + state.head.hcrc = ((state.flags >> 9) & 1); + state.head.done = true; + } + strm.adler = state.check = 0; + state.mode = TYPE; + break; + case DICTID: + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + strm.adler = state.check = zswap32(hold); + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = DICT; + /* falls through */ + case DICT: + if (state.havedict === 0) { + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + return Z_NEED_DICT; + } + strm.adler = state.check = 1/*adler32(0L, Z_NULL, 0)*/; + state.mode = TYPE; + /* falls through */ + case TYPE: + if (flush === Z_BLOCK || flush === Z_TREES) { break inf_leave; } + /* falls through */ + case TYPEDO: + if (state.last) { + //--- BYTEBITS() ---// + hold >>>= bits & 7; + bits -= bits & 7; + //---// + state.mode = CHECK; + break; + } + //=== NEEDBITS(3); */ + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.last = (hold & 0x01)/*BITS(1)*/; + //--- DROPBITS(1) ---// + hold >>>= 1; + bits -= 1; + //---// + + switch ((hold & 0x03)/*BITS(2)*/) { + case 0: /* stored block */ + //Tracev((stderr, "inflate: stored block%s\n", + // state.last ? " (last)" : "")); + state.mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + //Tracev((stderr, "inflate: fixed codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = LEN_; /* decode codes */ + if (flush === Z_TREES) { + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + break inf_leave; + } + break; + case 2: /* dynamic block */ + //Tracev((stderr, "inflate: dynamic codes block%s\n", + // state.last ? " (last)" : "")); + state.mode = TABLE; + break; + case 3: + strm.msg = 'invalid block type'; + state.mode = BAD; + } + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + break; + case STORED: + //--- BYTEBITS() ---// /* go to byte boundary */ + hold >>>= bits & 7; + bits -= bits & 7; + //---// + //=== NEEDBITS(32); */ + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if ((hold & 0xffff) !== ((hold >>> 16) ^ 0xffff)) { + strm.msg = 'invalid stored block lengths'; + state.mode = BAD; + break; + } + state.length = hold & 0xffff; + //Tracev((stderr, "inflate: stored length %u\n", + // state.length)); + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + state.mode = COPY_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case COPY_: + state.mode = COPY; + /* falls through */ + case COPY: + copy = state.length; + if (copy) { + if (copy > have) { copy = have; } + if (copy > left) { copy = left; } + if (copy === 0) { break inf_leave; } + //--- zmemcpy(put, next, copy); --- + utils.arraySet(output, input, next, copy, put); + //---// + have -= copy; + next += copy; + left -= copy; + put += copy; + state.length -= copy; + break; + } + //Tracev((stderr, "inflate: stored end\n")); + state.mode = TYPE; + break; + case TABLE: + //=== NEEDBITS(14); */ + while (bits < 14) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.nlen = (hold & 0x1f)/*BITS(5)*/ + 257; + //--- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + //---// + state.ndist = (hold & 0x1f)/*BITS(5)*/ + 1; + //--- DROPBITS(5) ---// + hold >>>= 5; + bits -= 5; + //---// + state.ncode = (hold & 0x0f)/*BITS(4)*/ + 4; + //--- DROPBITS(4) ---// + hold >>>= 4; + bits -= 4; + //---// +//#ifndef PKZIP_BUG_WORKAROUND + if (state.nlen > 286 || state.ndist > 30) { + strm.msg = 'too many length or distance symbols'; + state.mode = BAD; + break; + } +//#endif + //Tracev((stderr, "inflate: table sizes ok\n")); + state.have = 0; + state.mode = LENLENS; + /* falls through */ + case LENLENS: + while (state.have < state.ncode) { + //=== NEEDBITS(3); + while (bits < 3) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.lens[order[state.have++]] = (hold & 0x07);//BITS(3); + //--- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + //---// + } + while (state.have < 19) { + state.lens[order[state.have++]] = 0; + } + // We have separate tables & no pointers. 2 commented lines below not needed. + //state.next = state.codes; + //state.lencode = state.next; + // Switch to use dynamic table + state.lencode = state.lendyn; + state.lenbits = 7; + + opts = { bits: state.lenbits }; + ret = inflate_table(CODES, state.lens, 0, 19, state.lencode, 0, state.work, opts); + state.lenbits = opts.bits; + + if (ret) { + strm.msg = 'invalid code lengths set'; + state.mode = BAD; + break; + } + //Tracev((stderr, "inflate: code lengths ok\n")); + state.have = 0; + state.mode = CODELENS; + /* falls through */ + case CODELENS: + while (state.have < state.nlen + state.ndist) { + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) - 1)];/*BITS(state.lenbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if (here_val < 16) { + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.lens[state.have++] = here_val; + } + else { + if (here_val === 16) { + //=== NEEDBITS(here.bits + 2); + n = here_bits + 2; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + if (state.have === 0) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + len = state.lens[state.have - 1]; + copy = 3 + (hold & 0x03);//BITS(2); + //--- DROPBITS(2) ---// + hold >>>= 2; + bits -= 2; + //---// + } + else if (here_val === 17) { + //=== NEEDBITS(here.bits + 3); + n = here_bits + 3; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + len = 0; + copy = 3 + (hold & 0x07);//BITS(3); + //--- DROPBITS(3) ---// + hold >>>= 3; + bits -= 3; + //---// + } + else { + //=== NEEDBITS(here.bits + 7); + n = here_bits + 7; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + len = 0; + copy = 11 + (hold & 0x7f);//BITS(7); + //--- DROPBITS(7) ---// + hold >>>= 7; + bits -= 7; + //---// + } + if (state.have + copy > state.nlen + state.ndist) { + strm.msg = 'invalid bit length repeat'; + state.mode = BAD; + break; + } + while (copy--) { + state.lens[state.have++] = len; + } + } + } + + /* handle error breaks in while */ + if (state.mode === BAD) { break; } + + /* check for end-of-block code (better have one) */ + if (state.lens[256] === 0) { + strm.msg = 'invalid code -- missing end-of-block'; + state.mode = BAD; + break; + } + + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state.lenbits = 9; + + opts = { bits: state.lenbits }; + ret = inflate_table(LENS, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not needed. + // state.next_index = opts.table_index; + state.lenbits = opts.bits; + // state.lencode = state.next; + + if (ret) { + strm.msg = 'invalid literal/lengths set'; + state.mode = BAD; + break; + } + + state.distbits = 6; + //state.distcode.copy(state.codes); + // Switch to use dynamic table + state.distcode = state.distdyn; + opts = { bits: state.distbits }; + ret = inflate_table(DISTS, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts); + // We have separate tables & no pointers. 2 commented lines below not needed. + // state.next_index = opts.table_index; + state.distbits = opts.bits; + // state.distcode = state.next; + + if (ret) { + strm.msg = 'invalid distances set'; + state.mode = BAD; + break; + } + //Tracev((stderr, 'inflate: codes ok\n')); + state.mode = LEN_; + if (flush === Z_TREES) { break inf_leave; } + /* falls through */ + case LEN_: + state.mode = LEN; + /* falls through */ + case LEN: + if (have >= 6 && left >= 258) { + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + inflate_fast(strm, _out); + //--- LOAD() --- + put = strm.next_out; + output = strm.output; + left = strm.avail_out; + next = strm.next_in; + input = strm.input; + have = strm.avail_in; + hold = state.hold; + bits = state.bits; + //--- + + if (state.mode === TYPE) { + state.back = -1; + } + break; + } + state.back = 0; + for (;;) { + here = state.lencode[hold & ((1 << state.lenbits) - 1)]; /*BITS(state.lenbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if (here_bits <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if (here_op && (here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.lencode[last_val + + ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + //--- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + //---// + state.back += last_bits; + } + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.back += here_bits; + state.length = here_val; + if (here_op === 0) { + //Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + // "inflate: literal '%c'\n" : + // "inflate: literal 0x%02x\n", here.val)); + state.mode = LIT; + break; + } + if (here_op & 32) { + //Tracevv((stderr, "inflate: end of block\n")); + state.back = -1; + state.mode = TYPE; + break; + } + if (here_op & 64) { + strm.msg = 'invalid literal/length code'; + state.mode = BAD; + break; + } + state.extra = here_op & 15; + state.mode = LENEXT; + /* falls through */ + case LENEXT: + if (state.extra) { + //=== NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.length += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/; + //--- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + //---// + state.back += state.extra; + } + //Tracevv((stderr, "inflate: length %u\n", state.length)); + state.was = state.length; + state.mode = DIST; + /* falls through */ + case DIST: + for (;;) { + here = state.distcode[hold & ((1 << state.distbits) - 1)];/*BITS(state.distbits)*/ + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + if ((here_op & 0xf0) === 0) { + last_bits = here_bits; + last_op = here_op; + last_val = here_val; + for (;;) { + here = state.distcode[last_val + + ((hold & ((1 << (last_bits + last_op)) - 1))/*BITS(last.bits + last.op)*/ >> last_bits)]; + here_bits = here >>> 24; + here_op = (here >>> 16) & 0xff; + here_val = here & 0xffff; + + if ((last_bits + here_bits) <= bits) { break; } + //--- PULLBYTE() ---// + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + //---// + } + //--- DROPBITS(last.bits) ---// + hold >>>= last_bits; + bits -= last_bits; + //---// + state.back += last_bits; + } + //--- DROPBITS(here.bits) ---// + hold >>>= here_bits; + bits -= here_bits; + //---// + state.back += here_bits; + if (here_op & 64) { + strm.msg = 'invalid distance code'; + state.mode = BAD; + break; + } + state.offset = here_val; + state.extra = (here_op) & 15; + state.mode = DISTEXT; + /* falls through */ + case DISTEXT: + if (state.extra) { + //=== NEEDBITS(state.extra); + n = state.extra; + while (bits < n) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + state.offset += hold & ((1 << state.extra) - 1)/*BITS(state.extra)*/; + //--- DROPBITS(state.extra) ---// + hold >>>= state.extra; + bits -= state.extra; + //---// + state.back += state.extra; + } +//#ifdef INFLATE_STRICT + if (state.offset > state.dmax) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +//#endif + //Tracevv((stderr, "inflate: distance %u\n", state.offset)); + state.mode = MATCH; + /* falls through */ + case MATCH: + if (left === 0) { break inf_leave; } + copy = _out - left; + if (state.offset > copy) { /* copy from window */ + copy = state.offset - copy; + if (copy > state.whave) { + if (state.sane) { + strm.msg = 'invalid distance too far back'; + state.mode = BAD; + break; + } +// (!) This block is disabled in zlib defaults, +// don't enable it for binary compatibility +//#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR +// Trace((stderr, "inflate.c too far\n")); +// copy -= state.whave; +// if (copy > state.length) { copy = state.length; } +// if (copy > left) { copy = left; } +// left -= copy; +// state.length -= copy; +// do { +// output[put++] = 0; +// } while (--copy); +// if (state.length === 0) { state.mode = LEN; } +// break; +//#endif + } + if (copy > state.wnext) { + copy -= state.wnext; + from = state.wsize - copy; + } + else { + from = state.wnext - copy; + } + if (copy > state.length) { copy = state.length; } + from_source = state.window; + } + else { /* copy from output */ + from_source = output; + from = put - state.offset; + copy = state.length; + } + if (copy > left) { copy = left; } + left -= copy; + state.length -= copy; + do { + output[put++] = from_source[from++]; + } while (--copy); + if (state.length === 0) { state.mode = LEN; } + break; + case LIT: + if (left === 0) { break inf_leave; } + output[put++] = state.length; + left--; + state.mode = LEN; + break; + case CHECK: + if (state.wrap) { + //=== NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + // Use '|' instead of '+' to make sure that result is signed + hold |= input[next++] << bits; + bits += 8; + } + //===// + _out -= left; + strm.total_out += _out; + state.total += _out; + if (_out) { + strm.adler = state.check = + /*UPDATE(state.check, put - _out, _out);*/ + (state.flags ? crc32(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out)); + + } + _out = left; + // NB: crc32 stored as signed 32-bit int, zswap32 returns signed too + if ((state.flags ? hold : zswap32(hold)) !== state.check) { + strm.msg = 'incorrect data check'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + //Tracev((stderr, "inflate: check matches trailer\n")); + } + state.mode = LENGTH; + /* falls through */ + case LENGTH: + if (state.wrap && state.flags) { + //=== NEEDBITS(32); + while (bits < 32) { + if (have === 0) { break inf_leave; } + have--; + hold += input[next++] << bits; + bits += 8; + } + //===// + if (hold !== (state.total & 0xffffffff)) { + strm.msg = 'incorrect length check'; + state.mode = BAD; + break; + } + //=== INITBITS(); + hold = 0; + bits = 0; + //===// + //Tracev((stderr, "inflate: length matches trailer\n")); + } + state.mode = DONE; + /* falls through */ + case DONE: + ret = Z_STREAM_END; + break inf_leave; + case BAD: + ret = Z_DATA_ERROR; + break inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + /* falls through */ + default: + return Z_STREAM_ERROR; + } + } + + // inf_leave <- here is real place for "goto inf_leave", emulated via "break inf_leave" + + /* + Return from inflate(), updating the total counts and the check value. + If there was no progress during the inflate() call, return a buffer + error. Call updatewindow() to create and/or update the window state. + Note: a memory error from inflate() is non-recoverable. + */ + + //--- RESTORE() --- + strm.next_out = put; + strm.avail_out = left; + strm.next_in = next; + strm.avail_in = have; + state.hold = hold; + state.bits = bits; + //--- + + if (state.wsize || (_out !== strm.avail_out && state.mode < BAD && + (state.mode < CHECK || flush !== Z_FINISH))) { + if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) { + state.mode = MEM; + return Z_MEM_ERROR; + } + } + _in -= strm.avail_in; + _out -= strm.avail_out; + strm.total_in += _in; + strm.total_out += _out; + state.total += _out; + if (state.wrap && _out) { + strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/ + (state.flags ? crc32(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out)); + } + strm.data_type = state.bits + (state.last ? 64 : 0) + + (state.mode === TYPE ? 128 : 0) + + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0); + if (((_in === 0 && _out === 0) || flush === Z_FINISH) && ret === Z_OK) { + ret = Z_BUF_ERROR; + } + return ret; +} + +function inflateEnd(strm) { + + if (!strm || !strm.state /*|| strm->zfree == (free_func)0*/) { + return Z_STREAM_ERROR; + } + + var state = strm.state; + if (state.window) { + state.window = null; + } + strm.state = null; + return Z_OK; +} + +function inflateGetHeader(strm, head) { + var state; + + /* check state */ + if (!strm || !strm.state) { return Z_STREAM_ERROR; } + state = strm.state; + if ((state.wrap & 2) === 0) { return Z_STREAM_ERROR; } + + /* save header structure */ + state.head = head; + head.done = false; + return Z_OK; +} + +function inflateSetDictionary(strm, dictionary) { + var dictLength = dictionary.length; + + var state; + var dictid; + var ret; + + /* check state */ + if (!strm /* == Z_NULL */ || !strm.state /* == Z_NULL */) { return Z_STREAM_ERROR; } + state = strm.state; + + if (state.wrap !== 0 && state.mode !== DICT) { + return Z_STREAM_ERROR; + } + + /* check for correct dictionary identifier */ + if (state.mode === DICT) { + dictid = 1; /* adler32(0, null, 0)*/ + /* dictid = adler32(dictid, dictionary, dictLength); */ + dictid = adler32(dictid, dictionary, dictLength, 0); + if (dictid !== state.check) { + return Z_DATA_ERROR; + } + } + /* copy dictionary to window using updatewindow(), which will amend the + existing dictionary if appropriate */ + ret = updatewindow(strm, dictionary, dictLength, dictLength); + if (ret) { + state.mode = MEM; + return Z_MEM_ERROR; + } + state.havedict = 1; + // Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +} + +exports.inflateReset = inflateReset; +exports.inflateReset2 = inflateReset2; +exports.inflateResetKeep = inflateResetKeep; +exports.inflateInit = inflateInit; +exports.inflateInit2 = inflateInit2; +exports.inflate = inflate; +exports.inflateEnd = inflateEnd; +exports.inflateGetHeader = inflateGetHeader; +exports.inflateSetDictionary = inflateSetDictionary; +exports.inflateInfo = 'pako inflate (from Nodeca project)'; + +/* Not implemented +exports.inflateCopy = inflateCopy; +exports.inflateGetDictionary = inflateGetDictionary; +exports.inflateMark = inflateMark; +exports.inflatePrime = inflatePrime; +exports.inflateSync = inflateSync; +exports.inflateSyncPoint = inflateSyncPoint; +exports.inflateUndermine = inflateUndermine; +*/ + + +/***/ }, + +/***/ 2920 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +var utils = __webpack_require__(2519); + +var MAXBITS = 15; +var ENOUGH_LENS = 852; +var ENOUGH_DISTS = 592; +//var ENOUGH = (ENOUGH_LENS+ENOUGH_DISTS); + +var CODES = 0; +var LENS = 1; +var DISTS = 2; + +var lbase = [ /* Length codes 257..285 base */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 +]; + +var lext = [ /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78 +]; + +var dbase = [ /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577, 0, 0 +]; + +var dext = [ /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64 +]; + +module.exports = function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) +{ + var bits = opts.bits; + //here = opts.here; /* table entry for duplication */ + + var len = 0; /* a code's length in bits */ + var sym = 0; /* index of code symbols */ + var min = 0, max = 0; /* minimum and maximum code lengths */ + var root = 0; /* number of index bits for root table */ + var curr = 0; /* number of index bits for current table */ + var drop = 0; /* code bits to drop for sub-table */ + var left = 0; /* number of prefix codes available */ + var used = 0; /* code entries in table used */ + var huff = 0; /* Huffman code */ + var incr; /* for incrementing code, index */ + var fill; /* index for replicating entries */ + var low; /* low bits for current root entry */ + var mask; /* mask for low root bits */ + var next; /* next available space in table */ + var base = null; /* base value table to use */ + var base_index = 0; +// var shoextra; /* extra bits table to use */ + var end; /* use base and extra for symbol > end */ + var count = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* number of codes of each length */ + var offs = new utils.Buf16(MAXBITS + 1); //[MAXBITS+1]; /* offsets in table for each length */ + var extra = null; + var extra_index = 0; + + var here_bits, here_op, here_val; + + /* + Process a set of code lengths to create a canonical Huffman code. The + code lengths are lens[0..codes-1]. Each length corresponds to the + symbols 0..codes-1. The Huffman code is generated by first sorting the + symbols by length from short to long, and retaining the symbol order + for codes with equal lengths. Then the code starts with all zero bits + for the first code of the shortest length, and the codes are integer + increments for the same length, and zeros are appended as the length + increases. For the deflate format, these bits are stored backwards + from their more natural integer increment ordering, and so when the + decoding tables are built in the large loop below, the integer codes + are incremented backwards. + + This routine assumes, but does not check, that all of the entries in + lens[] are in the range 0..MAXBITS. The caller must assure this. + 1..MAXBITS is interpreted as that code length. zero means that that + symbol does not occur in this code. + + The codes are sorted by computing a count of codes for each length, + creating from that a table of starting indices for each length in the + sorted table, and then entering the symbols in order in the sorted + table. The sorted table is work[], with that space being provided by + the caller. + + The length counts are used for other purposes as well, i.e. finding + the minimum and maximum length codes, determining if there are any + codes at all, checking for a valid set of lengths, and looking ahead + at length counts to determine sub-table sizes when building the + decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) { + count[len] = 0; + } + for (sym = 0; sym < codes; sym++) { + count[lens[lens_index + sym]]++; + } + + /* bound code lengths, force root to be within code lengths */ + root = bits; + for (max = MAXBITS; max >= 1; max--) { + if (count[max] !== 0) { break; } + } + if (root > max) { + root = max; + } + if (max === 0) { /* no symbols to code at all */ + //table.op[opts.table_index] = 64; //here.op = (var char)64; /* invalid code marker */ + //table.bits[opts.table_index] = 1; //here.bits = (var char)1; + //table.val[opts.table_index++] = 0; //here.val = (var short)0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + + //table.op[opts.table_index] = 64; + //table.bits[opts.table_index] = 1; + //table.val[opts.table_index++] = 0; + table[table_index++] = (1 << 24) | (64 << 16) | 0; + + opts.bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min < max; min++) { + if (count[min] !== 0) { break; } + } + if (root < min) { + root = min; + } + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) { + return -1; + } /* over-subscribed */ + } + if (left > 0 && (type === CODES || max !== 1)) { + return -1; /* incomplete set */ + } + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) { + offs[len + 1] = offs[len] + count[len]; + } + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) { + if (lens[lens_index + sym] !== 0) { + work[offs[lens[lens_index + sym]]++] = sym; + } + } + + /* + Create and fill in decoding tables. In this loop, the table being + filled is at next and has curr index bits. The code being used is huff + with length len. That code is converted to an index by dropping drop + bits off of the bottom. For codes where len is less than drop + curr, + those top drop + curr - len bits are incremented through all values to + fill the table with replicated entries. + + root is the number of index bits for the root table. When len exceeds + root, sub-tables are created pointed to by the root entry with an index + of the low root bits of huff. This is saved in low to check for when a + new sub-table should be started. drop is zero when the root table is + being filled, and drop is root when sub-tables are being filled. + + When a new sub-table is needed, it is necessary to look ahead in the + code lengths to determine what size sub-table is needed. The length + counts are used for this, and so count[] is decremented as codes are + entered in the tables. + + used keeps track of how many table entries have been allocated from the + provided *table space. It is checked for LENS and DIST tables against + the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in + the initial root table size constants. See the comments in inftrees.h + for more information. + + sym increments through all symbols, and the loop terminates when + all codes of length max, i.e. all codes, have been processed. This + routine permits incomplete codes, so another loop after this one fills + in the rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + // poor man optimization - use if-else instead of switch, + // to avoid deopts in old v8 + if (type === CODES) { + base = extra = work; /* dummy value--not used */ + end = 19; + + } else if (type === LENS) { + base = lbase; + base_index -= 257; + extra = lext; + extra_index -= 257; + end = 256; + + } else { /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize opts for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = table_index; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = -1; /* trigger new sub-table when len > root */ + used = 1 << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + /* process all codes and make table entries */ + for (;;) { + /* create table entry */ + here_bits = len - drop; + if (work[sym] < end) { + here_op = 0; + here_val = work[sym]; + } + else if (work[sym] > end) { + here_op = extra[extra_index + work[sym]]; + here_val = base[base_index + work[sym]]; + } + else { + here_op = 32 + 64; /* end of block */ + here_val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = 1 << (len - drop); + fill = 1 << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + table[next + (huff >> drop) + fill] = (here_bits << 24) | (here_op << 16) | here_val |0; + } while (fill !== 0); + + /* backwards increment the len-bit code huff */ + incr = 1 << (len - 1); + while (huff & incr) { + incr >>= 1; + } + if (incr !== 0) { + huff &= incr - 1; + huff += incr; + } else { + huff = 0; + } + + /* go to next symbol, update count, len */ + sym++; + if (--count[len] === 0) { + if (len === max) { break; } + len = lens[lens_index + work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) !== low) { + /* if first time, transition to sub-tables */ + if (drop === 0) { + drop = root; + } + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = 1 << curr; + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) { break; } + curr++; + left <<= 1; + } + + /* check for enough space */ + used += 1 << curr; + if ((type === LENS && used > ENOUGH_LENS) || + (type === DISTS && used > ENOUGH_DISTS)) { + return 1; + } + + /* point entry in root table to sub-table */ + low = huff & mask; + /*table.op[low] = curr; + table.bits[low] = root; + table.val[low] = next - opts.table_index;*/ + table[low] = (root << 24) | (curr << 16) | (next - table_index) |0; + } + } + + /* fill in remaining table entry if code is incomplete (guaranteed to have + at most one remaining entry, since if the code is incomplete, the + maximum code length that was allowed to get this far is one bit) */ + if (huff !== 0) { + //table.op[next + huff] = 64; /* invalid code marker */ + //table.bits[next + huff] = len - drop; + //table.val[next + huff] = 0; + table[next + huff] = ((len - drop) << 24) | (64 << 16) |0; + } + + /* set return parameters */ + //opts.table_index += used; + opts.bits = root; + return 0; +}; + + +/***/ }, + +/***/ 6228 +(module) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +module.exports = { + 2: 'need dictionary', /* Z_NEED_DICT 2 */ + 1: 'stream end', /* Z_STREAM_END 1 */ + 0: '', /* Z_OK 0 */ + '-1': 'file error', /* Z_ERRNO (-1) */ + '-2': 'stream error', /* Z_STREAM_ERROR (-2) */ + '-3': 'data error', /* Z_DATA_ERROR (-3) */ + '-4': 'insufficient memory', /* Z_MEM_ERROR (-4) */ + '-5': 'buffer error', /* Z_BUF_ERROR (-5) */ + '-6': 'incompatible version' /* Z_VERSION_ERROR (-6) */ +}; + + +/***/ }, + +/***/ 2367 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +/* eslint-disable space-unary-ops */ + +var utils = __webpack_require__(2519); + +/* Public constants ==========================================================*/ +/* ===========================================================================*/ + + +//var Z_FILTERED = 1; +//var Z_HUFFMAN_ONLY = 2; +//var Z_RLE = 3; +var Z_FIXED = 4; +//var Z_DEFAULT_STRATEGY = 0; + +/* Possible values of the data_type field (though see inflate()) */ +var Z_BINARY = 0; +var Z_TEXT = 1; +//var Z_ASCII = 1; // = Z_TEXT +var Z_UNKNOWN = 2; + +/*============================================================================*/ + + +function zero(buf) { var len = buf.length; while (--len >= 0) { buf[len] = 0; } } + +// From zutil.h + +var STORED_BLOCK = 0; +var STATIC_TREES = 1; +var DYN_TREES = 2; +/* The three kinds of block type */ + +var MIN_MATCH = 3; +var MAX_MATCH = 258; +/* The minimum and maximum match lengths */ + +// From deflate.h +/* =========================================================================== + * Internal compression state. + */ + +var LENGTH_CODES = 29; +/* number of length codes, not counting the special END_BLOCK code */ + +var LITERALS = 256; +/* number of literal bytes 0..255 */ + +var L_CODES = LITERALS + 1 + LENGTH_CODES; +/* number of Literal or Length codes, including the END_BLOCK code */ + +var D_CODES = 30; +/* number of distance codes */ + +var BL_CODES = 19; +/* number of codes used to transfer the bit lengths */ + +var HEAP_SIZE = 2 * L_CODES + 1; +/* maximum heap size */ + +var MAX_BITS = 15; +/* All codes must not exceed MAX_BITS bits */ + +var Buf_size = 16; +/* size of bit buffer in bi_buf */ + + +/* =========================================================================== + * Constants + */ + +var MAX_BL_BITS = 7; +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +var END_BLOCK = 256; +/* end of block literal code */ + +var REP_3_6 = 16; +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +var REPZ_3_10 = 17; +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +var REPZ_11_138 = 18; +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +/* eslint-disable comma-spacing,array-bracket-spacing */ +var extra_lbits = /* extra bits for each length code */ + [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]; + +var extra_dbits = /* extra bits for each distance code */ + [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]; + +var extra_blbits = /* extra bits for each bit length code */ + [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7]; + +var bl_order = + [16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]; +/* eslint-enable comma-spacing,array-bracket-spacing */ + +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +/* =========================================================================== + * Local data. These are initialized only once. + */ + +// We pre-fill arrays with 0 to avoid uninitialized gaps + +var DIST_CODE_LEN = 512; /* see definition of array dist_code below */ + +// !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1 +var static_ltree = new Array((L_CODES + 2) * 2); +zero(static_ltree); +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see _tr_init + * below). + */ + +var static_dtree = new Array(D_CODES * 2); +zero(static_dtree); +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +var _dist_code = new Array(DIST_CODE_LEN); +zero(_dist_code); +/* Distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1); +zero(_length_code); +/* length code for each normalized match length (0 == MIN_MATCH) */ + +var base_length = new Array(LENGTH_CODES); +zero(base_length); +/* First normalized length for each code (0 = MIN_MATCH) */ + +var base_dist = new Array(D_CODES); +zero(base_dist); +/* First normalized distance for each code (0 = distance of 1) */ + + +function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) { + + this.static_tree = static_tree; /* static tree or NULL */ + this.extra_bits = extra_bits; /* extra bits for each code or NULL */ + this.extra_base = extra_base; /* base index for extra_bits */ + this.elems = elems; /* max number of elements in the tree */ + this.max_length = max_length; /* max bit length for the codes */ + + // show if `static_tree` has data or dummy - needed for monomorphic objects + this.has_stree = static_tree && static_tree.length; +} + + +var static_l_desc; +var static_d_desc; +var static_bl_desc; + + +function TreeDesc(dyn_tree, stat_desc) { + this.dyn_tree = dyn_tree; /* the dynamic tree */ + this.max_code = 0; /* largest code with non zero frequency */ + this.stat_desc = stat_desc; /* the corresponding static tree */ +} + + + +function d_code(dist) { + return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)]; +} + + +/* =========================================================================== + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. + */ +function put_short(s, w) { +// put_byte(s, (uch)((w) & 0xff)); +// put_byte(s, (uch)((ush)(w) >> 8)); + s.pending_buf[s.pending++] = (w) & 0xff; + s.pending_buf[s.pending++] = (w >>> 8) & 0xff; +} + + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +function send_bits(s, value, length) { + if (s.bi_valid > (Buf_size - length)) { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + put_short(s, s.bi_buf); + s.bi_buf = value >> (Buf_size - s.bi_valid); + s.bi_valid += length - Buf_size; + } else { + s.bi_buf |= (value << s.bi_valid) & 0xffff; + s.bi_valid += length; + } +} + + +function send_code(s, c, tree) { + send_bits(s, tree[c * 2]/*.Code*/, tree[c * 2 + 1]/*.Len*/); +} + + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +function bi_reverse(code, len) { + var res = 0; + do { + res |= code & 1; + code >>>= 1; + res <<= 1; + } while (--len > 0); + return res >>> 1; +} + + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +function bi_flush(s) { + if (s.bi_valid === 16) { + put_short(s, s.bi_buf); + s.bi_buf = 0; + s.bi_valid = 0; + + } else if (s.bi_valid >= 8) { + s.pending_buf[s.pending++] = s.bi_buf & 0xff; + s.bi_buf >>= 8; + s.bi_valid -= 8; + } +} + + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +function gen_bitlen(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var max_code = desc.max_code; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var extra = desc.stat_desc.extra_bits; + var base = desc.stat_desc.extra_base; + var max_length = desc.stat_desc.max_length; + var h; /* heap index */ + var n, m; /* iterate over the tree elements */ + var bits; /* bit length */ + var xbits; /* extra bits */ + var f; /* frequency */ + var overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) { + s.bl_count[bits] = 0; + } + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[s.heap[s.heap_max] * 2 + 1]/*.Len*/ = 0; /* root of the heap */ + + for (h = s.heap_max + 1; h < HEAP_SIZE; h++) { + n = s.heap[h]; + bits = tree[tree[n * 2 + 1]/*.Dad*/ * 2 + 1]/*.Len*/ + 1; + if (bits > max_length) { + bits = max_length; + overflow++; + } + tree[n * 2 + 1]/*.Len*/ = bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) { continue; } /* not a leaf node */ + + s.bl_count[bits]++; + xbits = 0; + if (n >= base) { + xbits = extra[n - base]; + } + f = tree[n * 2]/*.Freq*/; + s.opt_len += f * (bits + xbits); + if (has_stree) { + s.static_len += f * (stree[n * 2 + 1]/*.Len*/ + xbits); + } + } + if (overflow === 0) { return; } + + // Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length - 1; + while (s.bl_count[bits] === 0) { bits--; } + s.bl_count[bits]--; /* move one leaf down the tree */ + s.bl_count[bits + 1] += 2; /* move one overflow item as its brother */ + s.bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits !== 0; bits--) { + n = s.bl_count[bits]; + while (n !== 0) { + m = s.heap[--h]; + if (m > max_code) { continue; } + if (tree[m * 2 + 1]/*.Len*/ !== bits) { + // Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s.opt_len += (bits - tree[m * 2 + 1]/*.Len*/) * tree[m * 2]/*.Freq*/; + tree[m * 2 + 1]/*.Len*/ = bits; + } + n--; + } + } +} + + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +function gen_codes(tree, max_code, bl_count) +// ct_data *tree; /* the tree to decorate */ +// int max_code; /* largest code with non zero frequency */ +// ushf *bl_count; /* number of codes at each bit length */ +{ + var next_code = new Array(MAX_BITS + 1); /* next code value for each bit length */ + var code = 0; /* running code value */ + var bits; /* bit index */ + var n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits - 1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + //Assert (code + bl_count[MAX_BITS]-1 == (1< length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES - 1; code++) { + base_length[code] = length; + for (n = 0; n < (1 << extra_lbits[code]); n++) { + _length_code[length++] = code; + } + } + //Assert (length == 256, "tr_static_init: length != 256"); + /* Note that the length 255 (match length 258) can be represented + * in two different ways: code 284 + 5 bits or code 285, so we + * overwrite length_code[255] to use the best encoding: + */ + _length_code[length - 1] = code; + + /* Initialize the mapping dist (0..32K) -> dist code (0..29) */ + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1 << extra_dbits[code]); n++) { + _dist_code[dist++] = code; + } + } + //Assert (dist == 256, "tr_static_init: dist != 256"); + dist >>= 7; /* from now on, all distances are divided by 128 */ + for (; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1 << (extra_dbits[code] - 7)); n++) { + _dist_code[256 + dist++] = code; + } + } + //Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) { + bl_count[bits] = 0; + } + + n = 0; + while (n <= 143) { + static_ltree[n * 2 + 1]/*.Len*/ = 8; + n++; + bl_count[8]++; + } + while (n <= 255) { + static_ltree[n * 2 + 1]/*.Len*/ = 9; + n++; + bl_count[9]++; + } + while (n <= 279) { + static_ltree[n * 2 + 1]/*.Len*/ = 7; + n++; + bl_count[7]++; + } + while (n <= 287) { + static_ltree[n * 2 + 1]/*.Len*/ = 8; + n++; + bl_count[8]++; + } + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes(static_ltree, L_CODES + 1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n * 2 + 1]/*.Len*/ = 5; + static_dtree[n * 2]/*.Code*/ = bi_reverse(n, 5); + } + + // Now data ready and we can init static trees + static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS); + static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS); + static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS); + + //static_init_done = true; +} + + +/* =========================================================================== + * Initialize a new block. + */ +function init_block(s) { + var n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) { s.dyn_ltree[n * 2]/*.Freq*/ = 0; } + for (n = 0; n < D_CODES; n++) { s.dyn_dtree[n * 2]/*.Freq*/ = 0; } + for (n = 0; n < BL_CODES; n++) { s.bl_tree[n * 2]/*.Freq*/ = 0; } + + s.dyn_ltree[END_BLOCK * 2]/*.Freq*/ = 1; + s.opt_len = s.static_len = 0; + s.last_lit = s.matches = 0; +} + + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +function bi_windup(s) +{ + if (s.bi_valid > 8) { + put_short(s, s.bi_buf); + } else if (s.bi_valid > 0) { + //put_byte(s, (Byte)s->bi_buf); + s.pending_buf[s.pending++] = s.bi_buf; + } + s.bi_buf = 0; + s.bi_valid = 0; +} + +/* =========================================================================== + * Copy a stored block, storing first the length and its + * one's complement if requested. + */ +function copy_block(s, buf, len, header) +//DeflateState *s; +//charf *buf; /* the input data */ +//unsigned len; /* its length */ +//int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + + if (header) { + put_short(s, len); + put_short(s, ~len); + } +// while (len--) { +// put_byte(s, *buf++); +// } + utils.arraySet(s.pending_buf, s.window, buf, len, s.pending); + s.pending += len; +} + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +function smaller(tree, n, m, depth) { + var _n2 = n * 2; + var _m2 = m * 2; + return (tree[_n2]/*.Freq*/ < tree[_m2]/*.Freq*/ || + (tree[_n2]/*.Freq*/ === tree[_m2]/*.Freq*/ && depth[n] <= depth[m])); +} + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +function pqdownheap(s, tree, k) +// deflate_state *s; +// ct_data *tree; /* the tree to restore */ +// int k; /* node to move down */ +{ + var v = s.heap[k]; + var j = k << 1; /* left son of k */ + while (j <= s.heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s.heap_len && + smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s.heap[j], s.depth)) { break; } + + /* Exchange v with the smallest son */ + s.heap[k] = s.heap[j]; + k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s.heap[k] = v; +} + + +// inlined manually +// var SMALLEST = 1; + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +function compress_block(s, ltree, dtree) +// deflate_state *s; +// const ct_data *ltree; /* literal tree */ +// const ct_data *dtree; /* distance tree */ +{ + var dist; /* distance of matched string */ + var lc; /* match length or unmatched char (if dist == 0) */ + var lx = 0; /* running index in l_buf */ + var code; /* the code to send */ + var extra; /* number of extra bits to send */ + + if (s.last_lit !== 0) { + do { + dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | (s.pending_buf[s.d_buf + lx * 2 + 1]); + lc = s.pending_buf[s.l_buf + lx]; + lx++; + + if (dist === 0) { + send_code(s, lc, ltree); /* send a literal byte */ + //Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code + LITERALS + 1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra !== 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + //Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra !== 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + //Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, + // "pendingBuf overflow"); + + } while (lx < s.last_lit); + } + + send_code(s, END_BLOCK, ltree); +} + + +/* =========================================================================== + * Construct one Huffman tree and assigns the code bit strings and lengths. + * Update the total bit length for the current block. + * IN assertion: the field freq is set for all tree elements. + * OUT assertions: the fields len and code are set to the optimal bit length + * and corresponding code. The length opt_len is updated; static_len is + * also updated if stree is not null. The field max_code is set. + */ +function build_tree(s, desc) +// deflate_state *s; +// tree_desc *desc; /* the tree descriptor */ +{ + var tree = desc.dyn_tree; + var stree = desc.stat_desc.static_tree; + var has_stree = desc.stat_desc.has_stree; + var elems = desc.stat_desc.elems; + var n, m; /* iterate over heap elements */ + var max_code = -1; /* largest code with non zero frequency */ + var node; /* new node being created */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s.heap_len = 0; + s.heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n * 2]/*.Freq*/ !== 0) { + s.heap[++s.heap_len] = max_code = n; + s.depth[n] = 0; + + } else { + tree[n * 2 + 1]/*.Len*/ = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (s.heap_len < 2) { + node = s.heap[++s.heap_len] = (max_code < 2 ? ++max_code : 0); + tree[node * 2]/*.Freq*/ = 1; + s.depth[node] = 0; + s.opt_len--; + + if (has_stree) { + s.static_len -= stree[node * 2 + 1]/*.Len*/; + } + /* node is 0 or 1 so it does not have extra bits */ + } + desc.max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = (s.heap_len >> 1/*int /2*/); n >= 1; n--) { pqdownheap(s, tree, n); } + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + node = elems; /* next internal node of the tree */ + do { + //pqremove(s, tree, n); /* n = node of least frequency */ + /*** pqremove ***/ + n = s.heap[1/*SMALLEST*/]; + s.heap[1/*SMALLEST*/] = s.heap[s.heap_len--]; + pqdownheap(s, tree, 1/*SMALLEST*/); + /***/ + + m = s.heap[1/*SMALLEST*/]; /* m = node of next least frequency */ + + s.heap[--s.heap_max] = n; /* keep the nodes sorted by frequency */ + s.heap[--s.heap_max] = m; + + /* Create a new node father of n and m */ + tree[node * 2]/*.Freq*/ = tree[n * 2]/*.Freq*/ + tree[m * 2]/*.Freq*/; + s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1; + tree[n * 2 + 1]/*.Dad*/ = tree[m * 2 + 1]/*.Dad*/ = node; + + /* and insert the new node in the heap */ + s.heap[1/*SMALLEST*/] = node++; + pqdownheap(s, tree, 1/*SMALLEST*/); + + } while (s.heap_len >= 2); + + s.heap[--s.heap_max] = s.heap[1/*SMALLEST*/]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen(s, desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes(tree, max_code, s.bl_count); +} + + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. + */ +function scan_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + tree[(max_code + 1) * 2 + 1]/*.Len*/ = 0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]/*.Len*/; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + s.bl_tree[curlen * 2]/*.Freq*/ += count; + + } else if (curlen !== 0) { + + if (curlen !== prevlen) { s.bl_tree[curlen * 2]/*.Freq*/++; } + s.bl_tree[REP_3_6 * 2]/*.Freq*/++; + + } else if (count <= 10) { + s.bl_tree[REPZ_3_10 * 2]/*.Freq*/++; + + } else { + s.bl_tree[REPZ_11_138 * 2]/*.Freq*/++; + } + + count = 0; + prevlen = curlen; + + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +function send_tree(s, tree, max_code) +// deflate_state *s; +// ct_data *tree; /* the tree to be scanned */ +// int max_code; /* and its largest code of non zero frequency */ +{ + var n; /* iterates over all tree elements */ + var prevlen = -1; /* last emitted length */ + var curlen; /* length of current code */ + + var nextlen = tree[0 * 2 + 1]/*.Len*/; /* length of next code */ + + var count = 0; /* repeat count of the current code */ + var max_count = 7; /* max repeat count */ + var min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen === 0) { + max_count = 138; + min_count = 3; + } + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; + nextlen = tree[(n + 1) * 2 + 1]/*.Len*/; + + if (++count < max_count && curlen === nextlen) { + continue; + + } else if (count < min_count) { + do { send_code(s, curlen, s.bl_tree); } while (--count !== 0); + + } else if (curlen !== 0) { + if (curlen !== prevlen) { + send_code(s, curlen, s.bl_tree); + count--; + } + //Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s.bl_tree); + send_bits(s, count - 3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s.bl_tree); + send_bits(s, count - 3, 3); + + } else { + send_code(s, REPZ_11_138, s.bl_tree); + send_bits(s, count - 11, 7); + } + + count = 0; + prevlen = curlen; + if (nextlen === 0) { + max_count = 138; + min_count = 3; + + } else if (curlen === nextlen) { + max_count = 6; + min_count = 3; + + } else { + max_count = 7; + min_count = 4; + } + } +} + + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +function build_bl_tree(s) { + var max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, s.dyn_ltree, s.l_desc.max_code); + scan_tree(s, s.dyn_dtree, s.d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, s.bl_desc); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) { + if (s.bl_tree[bl_order[max_blindex] * 2 + 1]/*.Len*/ !== 0) { + break; + } + } + /* Update opt_len to include the bit length tree and counts */ + s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; + //Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + // s->opt_len, s->static_len)); + + return max_blindex; +} + + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +function send_all_trees(s, lcodes, dcodes, blcodes) +// deflate_state *s; +// int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + var rank; /* index in bl_order */ + + //Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + //Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + // "too many codes"); + //Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes - 257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes - 1, 5); + send_bits(s, blcodes - 4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + //Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1]/*.Len*/, 3); + } + //Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_ltree, lcodes - 1); /* literal tree */ + //Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, s.dyn_dtree, dcodes - 1); /* distance tree */ + //Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + + +/* =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: + * - TEXT if the two conditions below are satisfied: + * a) There are no non-portable control characters belonging to the + * "black list" (0..6, 14..25, 28..31). + * b) There is at least one printable character belonging to the + * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). + * - BINARY otherwise. + * - The following partially-portable control characters form a + * "gray list" that is ignored in this detection algorithm: + * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). + * IN assertion: the fields Freq of dyn_ltree are set. + */ +function detect_data_type(s) { + /* black_mask is the bit mask of black-listed bytes + * set bits 0..6, 14..25, and 28..31 + * 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + var black_mask = 0xf3ffc07f; + var n; + + /* Check for non-textual ("black-listed") bytes. */ + for (n = 0; n <= 31; n++, black_mask >>>= 1) { + if ((black_mask & 1) && (s.dyn_ltree[n * 2]/*.Freq*/ !== 0)) { + return Z_BINARY; + } + } + + /* Check for textual ("white-listed") bytes. */ + if (s.dyn_ltree[9 * 2]/*.Freq*/ !== 0 || s.dyn_ltree[10 * 2]/*.Freq*/ !== 0 || + s.dyn_ltree[13 * 2]/*.Freq*/ !== 0) { + return Z_TEXT; + } + for (n = 32; n < LITERALS; n++) { + if (s.dyn_ltree[n * 2]/*.Freq*/ !== 0) { + return Z_TEXT; + } + } + + /* There are no "black-listed" or "white-listed" bytes: + * this stream either is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + + +var static_init_done = false; + +/* =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +function _tr_init(s) +{ + + if (!static_init_done) { + tr_static_init(); + static_init_done = true; + } + + s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc); + s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc); + s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc); + + s.bi_buf = 0; + s.bi_valid = 0; + + /* Initialize the first block of the first file: */ + init_block(s); +} + + +/* =========================================================================== + * Send a stored block + */ +function _tr_stored_block(s, buf, stored_len, last) +//DeflateState *s; +//charf *buf; /* input block */ +//ulg stored_len; /* length of input block */ +//int last; /* one if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3); /* send block type */ + copy_block(s, buf, stored_len, true); /* with header */ +} + + +/* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. + */ +function _tr_align(s) { + send_bits(s, STATIC_TREES << 1, 3); + send_code(s, END_BLOCK, static_ltree); + bi_flush(s); +} + + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +function _tr_flush_block(s, buf, stored_len, last) +//DeflateState *s; +//charf *buf; /* input block, or NULL if too old */ +//ulg stored_len; /* length of input block */ +//int last; /* one if this is the last block for a file */ +{ + var opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + var max_blindex = 0; /* index of last bit length code of non zero freq */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s.level > 0) { + + /* Check if the file is binary or text */ + if (s.strm.data_type === Z_UNKNOWN) { + s.strm.data_type = detect_data_type(s); + } + + /* Construct the literal and distance trees */ + build_tree(s, s.l_desc); + // Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + + build_tree(s, s.d_desc); + // Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + // s->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute the block lengths in bytes. */ + opt_lenb = (s.opt_len + 3 + 7) >>> 3; + static_lenb = (s.static_len + 3 + 7) >>> 3; + + // Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + // opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + // s->last_lit)); + + if (static_lenb <= opt_lenb) { opt_lenb = static_lenb; } + + } else { + // Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + + if ((stored_len + 4 <= opt_lenb) && (buf !== -1)) { + /* 4: two words for the lengths */ + + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, last); + + } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) { + + send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3); + compress_block(s, static_ltree, static_dtree); + + } else { + send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3); + send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1); + compress_block(s, s.dyn_ltree, s.dyn_dtree); + } + // Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uLong implemented on 32 bits. + */ + init_block(s); + + if (last) { + bi_windup(s); + } + // Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + // s->compressed_len-7*last)); +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +function _tr_tally(s, dist, lc) +// deflate_state *s; +// unsigned dist; /* distance of matched string */ +// unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + //var out_length, in_length, dcode; + + s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff; + s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff; + + s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff; + s.last_lit++; + + if (dist === 0) { + /* lc is the unmatched char */ + s.dyn_ltree[lc * 2]/*.Freq*/++; + } else { + s.matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + //Assert((ush)dist < (ush)MAX_DIST(s) && + // (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + // (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]/*.Freq*/++; + s.dyn_dtree[d_code(dist) * 2]/*.Freq*/++; + } + +// (!) This block is disabled in zlib defaults, +// don't enable it for binary compatibility + +//#ifdef TRUNCATE_BLOCK +// /* Try to guess if it is profitable to stop the current block here */ +// if ((s.last_lit & 0x1fff) === 0 && s.level > 2) { +// /* Compute an upper bound for the compressed length */ +// out_length = s.last_lit*8; +// in_length = s.strstart - s.block_start; +// +// for (dcode = 0; dcode < D_CODES; dcode++) { +// out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]); +// } +// out_length >>>= 3; +// //Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", +// // s->last_lit, in_length, out_length, +// // 100L - out_length*100L/in_length)); +// if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) { +// return true; +// } +// } +//#endif + + return (s.last_lit === s.lit_bufsize - 1); + /* We avoid equality with lit_bufsize because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +exports._tr_init = _tr_init; +exports._tr_stored_block = _tr_stored_block; +exports._tr_flush_block = _tr_flush_block; +exports._tr_tally = _tr_tally; +exports._tr_align = _tr_align; + + +/***/ }, + +/***/ 7468 +(module) { + +"use strict"; + + +// (C) 1995-2013 Jean-loup Gailly and Mark Adler +// (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin +// +// This software is provided 'as-is', without any express or implied +// warranty. In no event will the authors be held liable for any damages +// arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it +// freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not +// claim that you wrote the original software. If you use this software +// in a product, an acknowledgment in the product documentation would be +// appreciated but is not required. +// 2. Altered source versions must be plainly marked as such, and must not be +// misrepresented as being the original software. +// 3. This notice may not be removed or altered from any source distribution. + +function ZStream() { + /* next input byte */ + this.input = null; // JS specific, because we have no pointers + this.next_in = 0; + /* number of bytes available at input */ + this.avail_in = 0; + /* total number of input bytes read so far */ + this.total_in = 0; + /* next output byte should be put there */ + this.output = null; // JS specific, because we have no pointers + this.next_out = 0; + /* remaining free space at output */ + this.avail_out = 0; + /* total number of bytes output so far */ + this.total_out = 0; + /* last error message, NULL if no error */ + this.msg = ''/*Z_NULL*/; + /* not visible by applications */ + this.state = null; + /* best guess about the data type: binary or text */ + this.data_type = 2/*Z_UNKNOWN*/; + /* adler32 value of the uncompressed data */ + this.adler = 0; +} + +module.exports = ZStream; + + +/***/ }, + +/***/ 884 +(module) { + +"use strict"; + + +/** @type {import('.')} */ +module.exports = [ + 'Float16Array', + 'Float32Array', + 'Float64Array', + 'Int8Array', + 'Int16Array', + 'Int32Array', + 'Uint8Array', + 'Uint8ClampedArray', + 'Uint16Array', + 'Uint32Array', + 'BigInt64Array', + 'BigUint64Array' +]; + + +/***/ }, + +/***/ 9964 +(module) { + +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +} ()) +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { return [] } + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { return '/' }; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function() { return 0; }; + + +/***/ }, + +/***/ 8843 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var callBound = __webpack_require__(2774); +var isRegex = __webpack_require__(1689); + +var $exec = callBound('RegExp.prototype.exec'); +var $TypeError = __webpack_require__(6785); + +/** @type {import('.')} */ +module.exports = function regexTester(regex) { + if (!isRegex(regex)) { + throw new $TypeError('`regex` must be a RegExp'); + } + return function test(s) { + return $exec(regex, s) !== null; + }; +}; + + +/***/ }, + +/***/ 1733 +(__unused_webpack_module, exports, __webpack_require__) { + +/* provided dependency */ var Buffer = __webpack_require__(783)["Buffer"]; +;(function (sax) { + // wrapper for non-node envs + sax.parser = function (strict, opt) { + return new SAXParser(strict, opt) + } + sax.SAXParser = SAXParser + sax.SAXStream = SAXStream + sax.createStream = createStream + + // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns. + // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)), + // since that's the earliest that a buffer overrun could occur. This way, checks are + // as rare as required, but as often as necessary to ensure never crossing this bound. + // Furthermore, buffers are only tested at most once per write(), so passing a very + // large string into write() might have undesirable effects, but this is manageable by + // the caller, so it is assumed to be safe. Thus, a call to write() may, in the extreme + // edge case, result in creating at most one complete copy of the string passed in. + // Set to Infinity to have unlimited buffers. + sax.MAX_BUFFER_LENGTH = 64 * 1024 + + var buffers = [ + 'comment', + 'sgmlDecl', + 'textNode', + 'tagName', + 'doctype', + 'procInstName', + 'procInstBody', + 'entity', + 'attribName', + 'attribValue', + 'cdata', + 'script', + ] + + sax.EVENTS = [ + 'text', + 'processinginstruction', + 'sgmldeclaration', + 'doctype', + 'comment', + 'opentagstart', + 'attribute', + 'opentag', + 'closetag', + 'opencdata', + 'cdata', + 'closecdata', + 'error', + 'end', + 'ready', + 'script', + 'opennamespace', + 'closenamespace', + ] + + function SAXParser(strict, opt) { + if (!(this instanceof SAXParser)) { + return new SAXParser(strict, opt) + } + + var parser = this + clearBuffers(parser) + parser.q = parser.c = '' + parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH + parser.encoding = null; + parser.opt = opt || {} + parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags + parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase' + parser.opt.maxEntityCount = parser.opt.maxEntityCount || 512 + parser.opt.maxEntityDepth = parser.opt.maxEntityDepth || 4 + parser.entityCount = parser.entityDepth = 0 + parser.tags = [] + parser.closed = parser.closedRoot = parser.sawRoot = false + parser.tag = parser.error = null + parser.strict = !!strict + parser.noscript = !!(strict || parser.opt.noscript) + parser.state = S.BEGIN + parser.strictEntities = parser.opt.strictEntities + parser.ENTITIES = + parser.strictEntities ? + Object.create(sax.XML_ENTITIES) + : Object.create(sax.ENTITIES) + parser.attribList = [] + + // namespaces form a prototype chain. + // it always points at the current tag, + // which protos to its parent tag. + if (parser.opt.xmlns) { + parser.ns = Object.create(rootNS) + } + + // disallow unquoted attribute values if not otherwise configured + // and strict mode is true + if (parser.opt.unquotedAttributeValues === undefined) { + parser.opt.unquotedAttributeValues = !strict + } + + // mostly just for error reporting + parser.trackPosition = parser.opt.position !== false + if (parser.trackPosition) { + parser.position = parser.line = parser.column = 0 + } + emit(parser, 'onready') + } + + if (!Object.create) { + Object.create = function (o) { + function F() {} + F.prototype = o + var newf = new F() + return newf + } + } + + if (!Object.keys) { + Object.keys = function (o) { + var a = [] + for (var i in o) if (o.hasOwnProperty(i)) a.push(i) + return a + } + } + + function checkBufferLength(parser) { + var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10) + var maxActual = 0 + for (var i = 0, l = buffers.length; i < l; i++) { + var len = parser[buffers[i]].length + if (len > maxAllowed) { + // Text/cdata nodes can get big, and since they're buffered, + // we can get here under normal conditions. + // Avoid issues by emitting the text node now, + // so at least it won't get any bigger. + switch (buffers[i]) { + case 'textNode': + closeText(parser) + break + + case 'cdata': + emitNode(parser, 'oncdata', parser.cdata) + parser.cdata = '' + break + + case 'script': + emitNode(parser, 'onscript', parser.script) + parser.script = '' + break + + default: + error(parser, 'Max buffer length exceeded: ' + buffers[i]) + } + } + maxActual = Math.max(maxActual, len) + } + // schedule the next check for the earliest possible buffer overrun. + var m = sax.MAX_BUFFER_LENGTH - maxActual + parser.bufferCheckPosition = m + parser.position + } + + function clearBuffers(parser) { + for (var i = 0, l = buffers.length; i < l; i++) { + parser[buffers[i]] = '' + } + } + + function flushBuffers(parser) { + closeText(parser) + if (parser.cdata !== '') { + emitNode(parser, 'oncdata', parser.cdata) + parser.cdata = '' + } + if (parser.script !== '') { + emitNode(parser, 'onscript', parser.script) + parser.script = '' + } + } + + SAXParser.prototype = { + end: function () { + end(this) + }, + write: write, + resume: function () { + this.error = null + return this + }, + close: function () { + return this.write(null) + }, + flush: function () { + flushBuffers(this) + }, + } + + var Stream + try { + Stream = (__webpack_require__(9760).Stream) + } catch (ex) { + Stream = function () {} + } + if (!Stream) Stream = function () {} + + var streamWraps = sax.EVENTS.filter(function (ev) { + return ev !== 'error' && ev !== 'end' + }) + + function createStream(strict, opt) { + return new SAXStream(strict, opt) + } + + function determineBufferEncoding(data, isEnd) { + // BOM-based detection is the most reliable signal when present. + if (data.length >= 2) { + if (data[0] === 0xff && data[1] === 0xfe) { + return 'utf-16le' + } + + if (data[0] === 0xfe && data[1] === 0xff) { + return 'utf-16be' + } + } + + if (data.length >= 3 && data[0] === 0xef && data[1] === 0xbb && data[2] === 0xbf) { + return 'utf8' + } + + if (data.length >= 4) { + // XML documents without a BOM still start with "' || isWhitespace(c) + } + + function isMatch(regex, c) { + return regex.test(c) + } + + function notMatch(regex, c) { + return !isMatch(regex, c) + } + + var S = 0 + sax.STATE = { + BEGIN: S++, // leading byte order mark or whitespace + BEGIN_WHITESPACE: S++, // leading whitespace + TEXT: S++, // general stuff + TEXT_ENTITY: S++, // & and such. + OPEN_WAKA: S++, // < + SGML_DECL: S++, // + SCRIPT: S++, // will close everything, otherwise. + var t = parser.tags.length + var tagName = parser.tagName + if (!parser.strict) { + tagName = tagName[parser.looseCase]() + } + var closeTo = tagName + while (t--) { + var close = parser.tags[t] + if (close.name !== closeTo) { + // fail the first time in strict mode + strictFail(parser, 'Unexpected close tag') + } else { + break + } + } + + // didn't find it. we already failed for strict, so just abort. + if (t < 0) { + strictFail(parser, 'Unmatched closing tag: ' + parser.tagName) + parser.textNode += '' + parser.state = S.TEXT + return + } + parser.tagName = tagName + var s = parser.tags.length + while (s-- > t) { + var tag = (parser.tag = parser.tags.pop()) + parser.tagName = parser.tag.name + emitNode(parser, 'onclosetag', parser.tagName) + + var x = {} + for (var i in tag.ns) { + x[i] = tag.ns[i] + } + + var parent = parser.tags[parser.tags.length - 1] || parser + if (parser.opt.xmlns && tag.ns !== parent.ns) { + // remove namespace bindings introduced by tag + Object.keys(tag.ns).forEach(function (p) { + var n = tag.ns[p] + emitNode(parser, 'onclosenamespace', { prefix: p, uri: n }) + }) + } + } + if (t === 0) parser.closedRoot = true + parser.tagName = parser.attribValue = parser.attribName = '' + parser.attribList.length = 0 + parser.state = S.TEXT + } + + function parseEntity(parser) { + var entity = parser.entity + var entityLC = entity.toLowerCase() + var num + var numStr = '' + + if (parser.ENTITIES[entity]) { + return parser.ENTITIES[entity] + } + if (parser.ENTITIES[entityLC]) { + return parser.ENTITIES[entityLC] + } + entity = entityLC + if (entity.charAt(0) === '#') { + if (entity.charAt(1) === 'x') { + entity = entity.slice(2) + num = parseInt(entity, 16) + numStr = num.toString(16) + } else { + entity = entity.slice(1) + num = parseInt(entity, 10) + numStr = num.toString(10) + } + } + entity = entity.replace(/^0+/, '') + if ( + isNaN(num) || + numStr.toLowerCase() !== entity || + num < 0 || + num > 0x10ffff + ) { + strictFail(parser, 'Invalid character entity') + return '&' + parser.entity + ';' + } + + return String.fromCodePoint(num) + } + + function beginWhiteSpace(parser, c) { + if (c === '<') { + parser.state = S.OPEN_WAKA + parser.startTagPosition = parser.position + } else if (!isWhitespace(c)) { + // have to process this as a text node. + // weird, but happens. + strictFail(parser, 'Non-whitespace before first tag.') + parser.textNode = c + parser.state = S.TEXT + } + } + + function charAt(chunk, i) { + var result = '' + if (i < chunk.length) { + result = chunk.charAt(i) + } + return result + } + + function write(chunk) { + var parser = this + if (this.error) { + throw this.error + } + if (parser.closed) { + return error( + parser, + 'Cannot write after close. Assign an onready handler.' + ) + } + if (chunk === null) { + return end(parser) + } + if (typeof chunk === 'object') { + chunk = chunk.toString() + } + var i = 0 + var c = '' + while (true) { + c = charAt(chunk, i++) + parser.c = c + + if (!c) { + break + } + + if (parser.trackPosition) { + parser.position++ + if (c === '\n') { + parser.line++ + parser.column = 0 + } else { + parser.column++ + } + } + + switch (parser.state) { + case S.BEGIN: + parser.state = S.BEGIN_WHITESPACE + if (c === '\uFEFF') { + continue + } + beginWhiteSpace(parser, c) + continue + + case S.BEGIN_WHITESPACE: + beginWhiteSpace(parser, c) + continue + + case S.TEXT: + if (parser.sawRoot && !parser.closedRoot) { + var starti = i - 1 + while (c && c !== '<' && c !== '&') { + c = charAt(chunk, i++) + if (c && parser.trackPosition) { + parser.position++ + if (c === '\n') { + parser.line++ + parser.column = 0 + } else { + parser.column++ + } + } + } + parser.textNode += chunk.substring(starti, i - 1) + } + if ( + c === '<' && + !(parser.sawRoot && parser.closedRoot && !parser.strict) + ) { + parser.state = S.OPEN_WAKA + parser.startTagPosition = parser.position + } else { + if ( + !isWhitespace(c) && + (!parser.sawRoot || parser.closedRoot) + ) { + strictFail(parser, 'Text data outside of root node.') + } + if (c === '&') { + parser.state = S.TEXT_ENTITY + } else { + parser.textNode += c + } + } + continue + + case S.SCRIPT: + // only non-strict + if (c === '<') { + parser.state = S.SCRIPT_ENDING + } else { + parser.script += c + } + continue + + case S.SCRIPT_ENDING: + if (c === '/') { + parser.state = S.CLOSE_TAG + } else { + parser.script += '<' + c + parser.state = S.SCRIPT + } + continue + + case S.OPEN_WAKA: + // either a /, ?, !, or text is coming next. + if (c === '!') { + parser.state = S.SGML_DECL + parser.sgmlDecl = '' + } else if (isWhitespace(c)) { + // wait for it... + } else if (isMatch(nameStart, c)) { + parser.state = S.OPEN_TAG + parser.tagName = c + } else if (c === '/') { + parser.state = S.CLOSE_TAG + parser.tagName = '' + } else if (c === '?') { + parser.state = S.PROC_INST + parser.procInstName = parser.procInstBody = '' + } else { + strictFail(parser, 'Unencoded <') + // if there was some whitespace, then add that in. + if (parser.startTagPosition + 1 < parser.position) { + var pad = parser.position - parser.startTagPosition + c = new Array(pad).join(' ') + c + } + parser.textNode += '<' + c + parser.state = S.TEXT + } + continue + + case S.SGML_DECL: + if (parser.sgmlDecl + c === '--') { + parser.state = S.COMMENT + parser.comment = '' + parser.sgmlDecl = '' + continue + } + + if ( + parser.doctype && + parser.doctype !== true && + parser.sgmlDecl + ) { + parser.state = S.DOCTYPE_DTD + parser.doctype += '') { + emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl) + parser.sgmlDecl = '' + parser.state = S.TEXT + } else if (isQuote(c)) { + parser.state = S.SGML_DECL_QUOTED + parser.sgmlDecl += c + } else { + parser.sgmlDecl += c + } + continue + + case S.SGML_DECL_QUOTED: + if (c === parser.q) { + parser.state = S.SGML_DECL + parser.q = '' + } + parser.sgmlDecl += c + continue + + case S.DOCTYPE: + if (c === '>') { + parser.state = S.TEXT + emitNode(parser, 'ondoctype', parser.doctype) + parser.doctype = true // just remember that we saw it. + } else { + parser.doctype += c + if (c === '[') { + parser.state = S.DOCTYPE_DTD + } else if (isQuote(c)) { + parser.state = S.DOCTYPE_QUOTED + parser.q = c + } + } + continue + + case S.DOCTYPE_QUOTED: + parser.doctype += c + if (c === parser.q) { + parser.q = '' + parser.state = S.DOCTYPE + } + continue + + case S.DOCTYPE_DTD: + if (c === ']') { + parser.doctype += c + parser.state = S.DOCTYPE + } else if (c === '<') { + parser.state = S.OPEN_WAKA + parser.startTagPosition = parser.position + } else if (isQuote(c)) { + parser.doctype += c + parser.state = S.DOCTYPE_DTD_QUOTED + parser.q = c + } else { + parser.doctype += c + } + continue + + case S.DOCTYPE_DTD_QUOTED: + parser.doctype += c + if (c === parser.q) { + parser.state = S.DOCTYPE_DTD + parser.q = '' + } + continue + + case S.COMMENT: + if (c === '-') { + parser.state = S.COMMENT_ENDING + } else { + parser.comment += c + } + continue + + case S.COMMENT_ENDING: + if (c === '-') { + parser.state = S.COMMENT_ENDED + parser.comment = textopts(parser.opt, parser.comment) + if (parser.comment) { + emitNode(parser, 'oncomment', parser.comment) + } + parser.comment = '' + } else { + parser.comment += '-' + c + parser.state = S.COMMENT + } + continue + + case S.COMMENT_ENDED: + if (c !== '>') { + strictFail(parser, 'Malformed comment') + // allow in non-strict mode, + // which is a comment of " blah -- bloo " + parser.comment += '--' + c + parser.state = S.COMMENT + } else if (parser.doctype && parser.doctype !== true) { + parser.state = S.DOCTYPE_DTD + } else { + parser.state = S.TEXT + } + continue + + case S.CDATA: + var starti = i - 1 + while (c && c !== ']') { + c = charAt(chunk, i++) + if (c && parser.trackPosition) { + parser.position++ + if (c === '\n') { + parser.line++ + parser.column = 0 + } else { + parser.column++ + } + } + } + parser.cdata += chunk.substring(starti, i - 1) + if (c === ']') { + parser.state = S.CDATA_ENDING + } + continue + + case S.CDATA_ENDING: + if (c === ']') { + parser.state = S.CDATA_ENDING_2 + } else { + parser.cdata += ']' + c + parser.state = S.CDATA + } + continue + + case S.CDATA_ENDING_2: + if (c === '>') { + if (parser.cdata) { + emitNode(parser, 'oncdata', parser.cdata) + } + emitNode(parser, 'onclosecdata') + parser.cdata = '' + parser.state = S.TEXT + } else if (c === ']') { + parser.cdata += ']' + } else { + parser.cdata += ']]' + c + parser.state = S.CDATA + } + continue + + case S.PROC_INST: + if (c === '?') { + parser.state = S.PROC_INST_ENDING + } else if (isWhitespace(c)) { + parser.state = S.PROC_INST_BODY + } else { + parser.procInstName += c + } + continue + + case S.PROC_INST_BODY: + if (!parser.procInstBody && isWhitespace(c)) { + continue + } else if (c === '?') { + parser.state = S.PROC_INST_ENDING + } else { + parser.procInstBody += c + } + continue + + case S.PROC_INST_ENDING: + if (c === '>') { + const procInstEndData = { + name: parser.procInstName, + body: parser.procInstBody, + } + validateXmlDeclarationEncoding(parser, procInstEndData) + emitNode(parser, 'onprocessinginstruction', procInstEndData) + parser.procInstName = parser.procInstBody = '' + parser.state = S.TEXT + } else { + parser.procInstBody += '?' + c + parser.state = S.PROC_INST_BODY + } + continue + + case S.OPEN_TAG: + if (isMatch(nameBody, c)) { + parser.tagName += c + } else { + newTag(parser) + if (c === '>') { + openTag(parser) + } else if (c === '/') { + parser.state = S.OPEN_TAG_SLASH + } else { + if (!isWhitespace(c)) { + strictFail(parser, 'Invalid character in tag name') + } + parser.state = S.ATTRIB + } + } + continue + + case S.OPEN_TAG_SLASH: + if (c === '>') { + openTag(parser, true) + closeTag(parser) + } else { + strictFail( + parser, + 'Forward-slash in opening tag not followed by >' + ) + parser.state = S.ATTRIB + } + continue + + case S.ATTRIB: + // haven't read the attribute name yet. + if (isWhitespace(c)) { + continue + } else if (c === '>') { + openTag(parser) + } else if (c === '/') { + parser.state = S.OPEN_TAG_SLASH + } else if (isMatch(nameStart, c)) { + parser.attribName = c + parser.attribValue = '' + parser.state = S.ATTRIB_NAME + } else { + strictFail(parser, 'Invalid attribute name') + } + continue + + case S.ATTRIB_NAME: + if (c === '=') { + parser.state = S.ATTRIB_VALUE + } else if (c === '>') { + strictFail(parser, 'Attribute without value') + parser.attribValue = parser.attribName + attrib(parser) + openTag(parser) + } else if (isWhitespace(c)) { + parser.state = S.ATTRIB_NAME_SAW_WHITE + } else if (isMatch(nameBody, c)) { + parser.attribName += c + } else { + strictFail(parser, 'Invalid attribute name') + } + continue + + case S.ATTRIB_NAME_SAW_WHITE: + if (c === '=') { + parser.state = S.ATTRIB_VALUE + } else if (isWhitespace(c)) { + continue + } else { + strictFail(parser, 'Attribute without value') + parser.tag.attributes[parser.attribName] = '' + parser.attribValue = '' + emitNode(parser, 'onattribute', { + name: parser.attribName, + value: '', + }) + parser.attribName = '' + if (c === '>') { + openTag(parser) + } else if (isMatch(nameStart, c)) { + parser.attribName = c + parser.state = S.ATTRIB_NAME + } else { + strictFail(parser, 'Invalid attribute name') + parser.state = S.ATTRIB + } + } + continue + + case S.ATTRIB_VALUE: + if (isWhitespace(c)) { + continue + } else if (isQuote(c)) { + parser.q = c + parser.state = S.ATTRIB_VALUE_QUOTED + } else { + if (!parser.opt.unquotedAttributeValues) { + error(parser, 'Unquoted attribute value') + } + parser.state = S.ATTRIB_VALUE_UNQUOTED + parser.attribValue = c + } + continue + + case S.ATTRIB_VALUE_QUOTED: + if (c !== parser.q) { + if (c === '&') { + parser.state = S.ATTRIB_VALUE_ENTITY_Q + } else { + parser.attribValue += c + } + continue + } + attrib(parser) + parser.q = '' + parser.state = S.ATTRIB_VALUE_CLOSED + continue + + case S.ATTRIB_VALUE_CLOSED: + if (isWhitespace(c)) { + parser.state = S.ATTRIB + } else if (c === '>') { + openTag(parser) + } else if (c === '/') { + parser.state = S.OPEN_TAG_SLASH + } else if (isMatch(nameStart, c)) { + strictFail(parser, 'No whitespace between attributes') + parser.attribName = c + parser.attribValue = '' + parser.state = S.ATTRIB_NAME + } else { + strictFail(parser, 'Invalid attribute name') + } + continue + + case S.ATTRIB_VALUE_UNQUOTED: + if (!isAttribEnd(c)) { + if (c === '&') { + parser.state = S.ATTRIB_VALUE_ENTITY_U + } else { + parser.attribValue += c + } + continue + } + attrib(parser) + if (c === '>') { + openTag(parser) + } else { + parser.state = S.ATTRIB + } + continue + + case S.CLOSE_TAG: + if (!parser.tagName) { + if (isWhitespace(c)) { + continue + } else if (notMatch(nameStart, c)) { + if (parser.script) { + parser.script += '') { + closeTag(parser) + } else if (isMatch(nameBody, c)) { + parser.tagName += c + } else if (parser.script) { + parser.script += '') { + closeTag(parser) + } else { + strictFail(parser, 'Invalid characters in closing tag') + } + continue + + case S.TEXT_ENTITY: + case S.ATTRIB_VALUE_ENTITY_Q: + case S.ATTRIB_VALUE_ENTITY_U: + var returnState + var buffer + switch (parser.state) { + case S.TEXT_ENTITY: + returnState = S.TEXT + buffer = 'textNode' + break + + case S.ATTRIB_VALUE_ENTITY_Q: + returnState = S.ATTRIB_VALUE_QUOTED + buffer = 'attribValue' + break + + case S.ATTRIB_VALUE_ENTITY_U: + returnState = S.ATTRIB_VALUE_UNQUOTED + buffer = 'attribValue' + break + } + + if (c === ';') { + var parsedEntity = parseEntity(parser) + if ( + parser.opt.unparsedEntities && + !Object.values(sax.XML_ENTITIES).includes(parsedEntity) + ) { + if ((parser.entityCount += 1) > parser.opt.maxEntityCount) { + error( + parser, + 'Parsed entity count exceeds max entity count' + ) + } + + if ((parser.entityDepth += 1) > parser.opt.maxEntityDepth) { + error( + parser, + 'Parsed entity depth exceeds max entity depth' + ) + } + + parser.entity = '' + parser.state = returnState + parser.write(parsedEntity) + parser.entityDepth -= 1 + } else { + parser[buffer] += parsedEntity + parser.entity = '' + parser.state = returnState + } + } else if ( + isMatch(parser.entity.length ? entityBody : entityStart, c) + ) { + parser.entity += c + } else { + strictFail(parser, 'Invalid character in entity name') + parser[buffer] += '&' + parser.entity + c + parser.entity = '' + parser.state = returnState + } + + continue + + default: /* istanbul ignore next */ { + throw new Error(parser, 'Unknown state: ' + parser.state) + } + } + } // while + + if (parser.position >= parser.bufferCheckPosition) { + checkBufferLength(parser) + } + return parser + } + + /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */ + /* istanbul ignore next */ + if (!String.fromCodePoint) { + ;(function () { + var stringFromCharCode = String.fromCharCode + var floor = Math.floor + var fromCodePoint = function () { + var MAX_SIZE = 0x4000 + var codeUnits = [] + var highSurrogate + var lowSurrogate + var index = -1 + var length = arguments.length + if (!length) { + return '' + } + var result = '' + while (++index < length) { + var codePoint = Number(arguments[index]) + if ( + !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` + codePoint < 0 || // not a valid Unicode code point + codePoint > 0x10ffff || // not a valid Unicode code point + floor(codePoint) !== codePoint // not an integer + ) { + throw RangeError('Invalid code point: ' + codePoint) + } + if (codePoint <= 0xffff) { + // BMP code point + codeUnits.push(codePoint) + } else { + // Astral code point; split in surrogate halves + // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + codePoint -= 0x10000 + highSurrogate = (codePoint >> 10) + 0xd800 + lowSurrogate = (codePoint % 0x400) + 0xdc00 + codeUnits.push(highSurrogate, lowSurrogate) + } + if (index + 1 === length || codeUnits.length > MAX_SIZE) { + result += stringFromCharCode.apply(null, codeUnits) + codeUnits.length = 0 + } + } + return result + } + /* istanbul ignore next */ + if (Object.defineProperty) { + Object.defineProperty(String, 'fromCodePoint', { + value: fromCodePoint, + configurable: true, + writable: true, + }) + } else { + String.fromCodePoint = fromCodePoint + } + })() + } +})( false ? (0) : exports) + + +/***/ }, + +/***/ 6255 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var GetIntrinsic = __webpack_require__(8651); +var define = __webpack_require__(9295); +var hasDescriptors = __webpack_require__(8890)(); +var gOPD = __webpack_require__(8109); + +var $TypeError = __webpack_require__(6785); +var $floor = GetIntrinsic('%Math.floor%'); + +/** @type {import('.')} */ +module.exports = function setFunctionLength(fn, length) { + if (typeof fn !== 'function') { + throw new $TypeError('`fn` is not a function'); + } + if (typeof length !== 'number' || length < 0 || length > 0xFFFFFFFF || $floor(length) !== length) { + throw new $TypeError('`length` must be a positive 32-bit integer'); + } + + var loose = arguments.length > 2 && !!arguments[2]; + + var functionLengthIsConfigurable = true; + var functionLengthIsWritable = true; + if ('length' in fn && gOPD) { + var desc = gOPD(fn, 'length'); + if (desc && !desc.configurable) { + functionLengthIsConfigurable = false; + } + if (desc && !desc.writable) { + functionLengthIsWritable = false; + } + } + + if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) { + if (hasDescriptors) { + define(/** @type {Parameters[0]} */ (fn), 'length', length, true, true); + } else { + define(/** @type {Parameters[0]} */ (fn), 'length', length); + } + } + return fn; +}; + + +/***/ }, + +/***/ 9760 +(module, __unused_webpack_exports, __webpack_require__) { + +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +module.exports = Stream; + +var EE = (__webpack_require__(4785).EventEmitter); +var inherits = __webpack_require__(9784); + +inherits(Stream, EE); +Stream.Readable = __webpack_require__(8261); +Stream.Writable = __webpack_require__(9781); +Stream.Duplex = __webpack_require__(4903); +Stream.Transform = __webpack_require__(8569); +Stream.PassThrough = __webpack_require__(7723); +Stream.finished = __webpack_require__(2167) +Stream.pipeline = __webpack_require__(3765) + +// Backwards-compat with node 0.4.x +Stream.Stream = Stream; + + + +// old-style streams. Note that the pipe method (the only relevant +// part of this class) is overridden in the Readable class. + +function Stream() { + EE.call(this); +} + +Stream.prototype.pipe = function(dest, options) { + var source = this; + + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } + + source.on('data', ondata); + + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + + dest.on('drain', ondrain); + + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + + dest.end(); + } + + + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + + if (typeof dest.destroy === 'function') dest.destroy(); + } + + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. + } + } + + source.on('error', onerror); + dest.on('error', onerror); + + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + + source.removeListener('end', onend); + source.removeListener('close', onclose); + + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + + dest.removeListener('close', cleanup); + } + + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; +}; + + +/***/ }, + +/***/ 3797 +(module) { + +"use strict"; + + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } + +var codes = {}; + +function createErrorType(code, message, Base) { + if (!Base) { + Base = Error; + } + + function getMessage(arg1, arg2, arg3) { + if (typeof message === 'string') { + return message; + } else { + return message(arg1, arg2, arg3); + } + } + + var NodeError = + /*#__PURE__*/ + function (_Base) { + _inheritsLoose(NodeError, _Base); + + function NodeError(arg1, arg2, arg3) { + return _Base.call(this, getMessage(arg1, arg2, arg3)) || this; + } + + return NodeError; + }(Base); + + NodeError.prototype.name = Base.name; + NodeError.prototype.code = code; + codes[code] = NodeError; +} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js + + +function oneOf(expected, thing) { + if (Array.isArray(expected)) { + var len = expected.length; + expected = expected.map(function (i) { + return String(i); + }); + + if (len > 2) { + return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1]; + } else if (len === 2) { + return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]); + } else { + return "of ".concat(thing, " ").concat(expected[0]); + } + } else { + return "of ".concat(thing, " ").concat(String(expected)); + } +} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith + + +function startsWith(str, search, pos) { + return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search; +} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith + + +function endsWith(str, search, this_len) { + if (this_len === undefined || this_len > str.length) { + this_len = str.length; + } + + return str.substring(this_len - search.length, this_len) === search; +} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes + + +function includes(str, search, start) { + if (typeof start !== 'number') { + start = 0; + } + + if (start + search.length > str.length) { + return false; + } else { + return str.indexOf(search, start) !== -1; + } +} + +createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) { + return 'The value "' + value + '" is invalid for option "' + name + '"'; +}, TypeError); +createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) { + // determiner: 'must be' or 'must not be' + var determiner; + + if (typeof expected === 'string' && startsWith(expected, 'not ')) { + determiner = 'must not be'; + expected = expected.replace(/^not /, ''); + } else { + determiner = 'must be'; + } + + var msg; + + if (endsWith(name, ' argument')) { + // For cases like 'first argument' + msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); + } else { + var type = includes(name, '.') ? 'property' : 'argument'; + msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type')); + } + + msg += ". Received type ".concat(typeof actual); + return msg; +}, TypeError); +createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF'); +createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) { + return 'The ' + name + ' method is not implemented'; +}); +createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close'); +createErrorType('ERR_STREAM_DESTROYED', function (name) { + return 'Cannot call ' + name + ' after a stream was destroyed'; +}); +createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times'); +createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable'); +createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end'); +createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError); +createErrorType('ERR_UNKNOWN_ENCODING', function (arg) { + return 'Unknown encoding: ' + arg; +}, TypeError); +createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event'); +module.exports.F = codes; + + +/***/ }, + +/***/ 4903 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a duplex stream is just a stream that is both readable and writable. +// Since JS doesn't have multiple prototypal inheritance, this class +// prototypally inherits from Readable, and then parasitically from +// Writable. + + + +/**/ +var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) keys.push(key); + return keys; +}; +/**/ + +module.exports = Duplex; +var Readable = __webpack_require__(8261); +var Writable = __webpack_require__(9781); +__webpack_require__(9784)(Duplex, Readable); +{ + // Allow the keys array to be GC'ed. + var keys = objectKeys(Writable.prototype); + for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; + } +} +function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); + Readable.call(this, options); + Writable.call(this, options); + this.allowHalfOpen = true; + if (options) { + if (options.readable === false) this.readable = false; + if (options.writable === false) this.writable = false; + if (options.allowHalfOpen === false) { + this.allowHalfOpen = false; + this.once('end', onend); + } + } +} +Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.highWaterMark; + } +}); +Object.defineProperty(Duplex.prototype, 'writableBuffer', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState && this._writableState.getBuffer(); + } +}); +Object.defineProperty(Duplex.prototype, 'writableLength', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.length; + } +}); + +// the no-half-open enforcer +function onend() { + // If the writable side ended, then we're ok. + if (this._writableState.ended) return; + + // no more data can be written. + // But allow more writes to happen in this tick. + process.nextTick(onEndNT, this); +} +function onEndNT(self) { + self.end(); +} +Object.defineProperty(Duplex.prototype, 'destroyed', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._readableState === undefined || this._writableState === undefined) { + return false; + } + return this._readableState.destroyed && this._writableState.destroyed; + }, + set: function set(value) { + // we ignore the value if the stream + // has not been initialized yet + if (this._readableState === undefined || this._writableState === undefined) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + this._writableState.destroyed = value; + } +}); + +/***/ }, + +/***/ 7723 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a passthrough stream. +// basically just the most minimal sort of Transform stream. +// Every written chunk gets output as-is. + + + +module.exports = PassThrough; +var Transform = __webpack_require__(8569); +__webpack_require__(9784)(PassThrough, Transform); +function PassThrough(options) { + if (!(this instanceof PassThrough)) return new PassThrough(options); + Transform.call(this, options); +} +PassThrough.prototype._transform = function (chunk, encoding, cb) { + cb(null, chunk); +}; + +/***/ }, + +/***/ 8261 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +module.exports = Readable; + +/**/ +var Duplex; +/**/ + +Readable.ReadableState = ReadableState; + +/**/ +var EE = (__webpack_require__(4785).EventEmitter); +var EElistenerCount = function EElistenerCount(emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +/**/ +var Stream = __webpack_require__(9018); +/**/ + +var Buffer = (__webpack_require__(783).Buffer); +var OurUint8Array = (typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} + +/**/ +var debugUtil = __webpack_require__(7199); +var debug; +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function debug() {}; +} +/**/ + +var BufferList = __webpack_require__(182); +var destroyImpl = __webpack_require__(7385); +var _require = __webpack_require__(8130), + getHighWaterMark = _require.getHighWaterMark; +var _require$codes = (__webpack_require__(3797)/* .codes */ .F), + ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, + ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF, + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; + +// Lazy loaded to improve the startup performance. +var StringDecoder; +var createReadableStreamAsyncIterator; +var from; +__webpack_require__(9784)(Readable, Stream); +var errorOrDestroy = destroyImpl.errorOrDestroy; +var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; +function prependListener(emitter, event, fn) { + // Sadly this is not cacheable as some libraries bundle their own + // event emitter implementation with them. + if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); + + // This is a hack to make sure that our error handler is attached before any + // userland ones. NEVER DO THIS. This is here only because this code needs + // to continue to work with older versions of Node.js that do not include + // the prependListener() method. The goal is to eventually remove this hack. + if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; +} +function ReadableState(options, stream, isDuplex) { + Duplex = Duplex || __webpack_require__(4903); + options = options || {}; + + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream. + // These options can be provided separately as readableXXX and writableXXX. + if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; + + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); + + // A linked list is used to store data chunks instead of an array because the + // linked list can remove elements from the beginning faster than + // array.shift() + this.buffer = new BufferList(); + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // a flag to be able to tell if the event 'readable'/'data' is emitted + // immediately, or on a later tick. We set this to true at first, because + // any actions that shouldn't happen until "later" should generally also + // not happen before the first read call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + this.paused = true; + + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; + + // Should .destroy() be called after 'end' (and potentially 'finish') + this.autoDestroy = !!options.autoDestroy; + + // has it been destroyed + this.destroyed = false; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + + // if true, a maybeReadMore has been scheduled + this.readingMore = false; + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = (__webpack_require__(3143)/* .StringDecoder */ .I); + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} +function Readable(options) { + Duplex = Duplex || __webpack_require__(4903); + if (!(this instanceof Readable)) return new Readable(options); + + // Checking for a Stream.Duplex instance is faster here instead of inside + // the ReadableState constructor, at least with V8 6.5 + var isDuplex = this instanceof Duplex; + this._readableState = new ReadableState(options, this, isDuplex); + + // legacy + this.readable = true; + if (options) { + if (typeof options.read === 'function') this._read = options.read; + if (typeof options.destroy === 'function') this._destroy = options.destroy; + } + Stream.call(this); +} +Object.defineProperty(Readable.prototype, 'destroyed', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._readableState === undefined) { + return false; + } + return this._readableState.destroyed; + }, + set: function set(value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._readableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + } +}); +Readable.prototype.destroy = destroyImpl.destroy; +Readable.prototype._undestroy = destroyImpl.undestroy; +Readable.prototype._destroy = function (err, cb) { + cb(err); +}; + +// Manually shove something into the read() buffer. +// This returns true if the highWaterMark has not been hit yet, +// similar to how Writable.write() returns true if you should +// write() some more. +Readable.prototype.push = function (chunk, encoding) { + var state = this._readableState; + var skipChunkCheck; + if (!state.objectMode) { + if (typeof chunk === 'string') { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = Buffer.from(chunk, encoding); + encoding = ''; + } + skipChunkCheck = true; + } + } else { + skipChunkCheck = true; + } + return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); +}; + +// Unshift should *always* be something directly out of read() +Readable.prototype.unshift = function (chunk) { + return readableAddChunk(this, chunk, null, true, false); +}; +function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { + debug('readableAddChunk', chunk); + var state = stream._readableState; + if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else { + var er; + if (!skipChunkCheck) er = chunkInvalid(state, chunk); + if (er) { + errorOrDestroy(stream, er); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { + chunk = _uint8ArrayToBuffer(chunk); + } + if (addToFront) { + if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true); + } else if (state.ended) { + errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF()); + } else if (state.destroyed) { + return false; + } else { + state.reading = false; + if (state.decoder && !encoding) { + chunk = state.decoder.write(chunk); + if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); + } else { + addChunk(stream, state, chunk, false); + } + } + } else if (!addToFront) { + state.reading = false; + maybeReadMore(stream, state); + } + } + + // We can push more data if we are below the highWaterMark. + // Also, if we have no data yet, we can stand some more bytes. + // This is to work around cases where hwm=0, such as the repl. + return !state.ended && (state.length < state.highWaterMark || state.length === 0); +} +function addChunk(stream, state, chunk, addToFront) { + if (state.flowing && state.length === 0 && !state.sync) { + state.awaitDrain = 0; + stream.emit('data', chunk); + } else { + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); + if (state.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state); +} +function chunkInvalid(state, chunk) { + var er; + if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk); + } + return er; +} +Readable.prototype.isPaused = function () { + return this._readableState.flowing === false; +}; + +// backwards compatibility. +Readable.prototype.setEncoding = function (enc) { + if (!StringDecoder) StringDecoder = (__webpack_require__(3143)/* .StringDecoder */ .I); + var decoder = new StringDecoder(enc); + this._readableState.decoder = decoder; + // If setEncoding(null), decoder.encoding equals utf8 + this._readableState.encoding = this._readableState.decoder.encoding; + + // Iterate over current buffer to convert already stored Buffers: + var p = this._readableState.buffer.head; + var content = ''; + while (p !== null) { + content += decoder.write(p.data); + p = p.next; + } + this._readableState.buffer.clear(); + if (content !== '') this._readableState.buffer.push(content); + this._readableState.length = content.length; + return this; +}; + +// Don't raise the hwm > 1GB +var MAX_HWM = 0x40000000; +function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE. + n = MAX_HWM; + } else { + // Get the next highest power of 2 to prevent increasing hwm excessively in + // tiny amounts + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; +} + +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function howMuchToRead(n, state) { + if (n <= 0 || state.length === 0 && state.ended) return 0; + if (state.objectMode) return 1; + if (n !== n) { + // Only flow one buffer at a time + if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; + } + // If we're asking for more than the current hwm, then raise the hwm. + if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); + if (n <= state.length) return n; + // Don't have enough + if (!state.ended) { + state.needReadable = true; + return 0; + } + return state.length; +} + +// you can override either this method, or the async _read(n) below. +Readable.prototype.read = function (n) { + debug('read', n); + n = parseInt(n, 10); + var state = this._readableState; + var nOrig = n; + if (n !== 0) state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) { + debug('read: emitReadable', state.length, state.ended); + if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); + return null; + } + n = howMuchToRead(n, state); + + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) endReadable(this); + return null; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + debug('need readable', doRead); + + // if we currently have less than the highWaterMark, then also read some + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + debug('length less than watermark', doRead); + } + + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) { + doRead = false; + debug('reading or ended', doRead); + } else if (doRead) { + debug('do read'); + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (!state.reading) n = howMuchToRead(nOrig, state); + } + var ret; + if (n > 0) ret = fromList(n, state);else ret = null; + if (ret === null) { + state.needReadable = state.length <= state.highWaterMark; + n = 0; + } else { + state.length -= n; + state.awaitDrain = 0; + } + if (state.length === 0) { + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (!state.ended) state.needReadable = true; + + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended) endReadable(this); + } + if (ret !== null) this.emit('data', ret); + return ret; +}; +function onEofChunk(stream, state) { + debug('onEofChunk'); + if (state.ended) return; + if (state.decoder) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + if (state.sync) { + // if we are sync, wait until next tick to emit the data. + // Otherwise we risk emitting data in the flow() + // the readable code triggers during a read() call + emitReadable(stream); + } else { + // emit 'readable' now to make sure it gets picked up. + state.needReadable = false; + if (!state.emittedReadable) { + state.emittedReadable = true; + emitReadable_(stream); + } + } +} + +// Don't emit readable right away in sync mode, because this can trigger +// another read() call => stack overflow. This way, it might trigger +// a nextTick recursion warning, but that's not so bad. +function emitReadable(stream) { + var state = stream._readableState; + debug('emitReadable', state.needReadable, state.emittedReadable); + state.needReadable = false; + if (!state.emittedReadable) { + debug('emitReadable', state.flowing); + state.emittedReadable = true; + process.nextTick(emitReadable_, stream); + } +} +function emitReadable_(stream) { + var state = stream._readableState; + debug('emitReadable_', state.destroyed, state.length, state.ended); + if (!state.destroyed && (state.length || state.ended)) { + stream.emit('readable'); + state.emittedReadable = false; + } + + // The stream needs another readable event if + // 1. It is not flowing, as the flow mechanism will take + // care of it. + // 2. It is not ended. + // 3. It is below the highWaterMark, so we can schedule + // another readable later. + state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark; + flow(stream); +} + +// at this point, the user has presumably seen the 'readable' event, +// and called read() to consume some data. that may have triggered +// in turn another _read(n) call, in which case reading = true if +// it's in progress. +// However, if we're not ended, or reading, and the length < hwm, +// then go ahead and try to read some more preemptively. +function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + process.nextTick(maybeReadMore_, stream, state); + } +} +function maybeReadMore_(stream, state) { + // Attempt to read more data if we should. + // + // The conditions for reading more data are (one of): + // - Not enough data buffered (state.length < state.highWaterMark). The loop + // is responsible for filling the buffer with enough data if such data + // is available. If highWaterMark is 0 and we are not in the flowing mode + // we should _not_ attempt to buffer any extra data. We'll get more data + // when the stream consumer calls read() instead. + // - No data in the buffer, and the stream is in flowing mode. In this mode + // the loop below is responsible for ensuring read() is called. Failing to + // call read here would abort the flow and there's no other mechanism for + // continuing the flow if the stream consumer has just subscribed to the + // 'data' event. + // + // In addition to the above conditions to keep reading data, the following + // conditions prevent the data from being read: + // - The stream has ended (state.ended). + // - There is already a pending 'read' operation (state.reading). This is a + // case where the the stream has called the implementation defined _read() + // method, but they are processing the call asynchronously and have _not_ + // called push() with new data. In this case we skip performing more + // read()s. The execution ends in this method again after the _read() ends + // up calling push() with more data. + while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) { + var len = state.length; + debug('maybeReadMore read 0'); + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break; + } + state.readingMore = false; +} + +// abstract method. to be overridden in specific implementation classes. +// call cb(er, data) where data is <= n in length. +// for virtual (non-string, non-buffer) streams, "length" is somewhat +// arbitrary, and perhaps not very meaningful. +Readable.prototype._read = function (n) { + errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()')); +}; +Readable.prototype.pipe = function (dest, pipeOpts) { + var src = this; + var state = this._readableState; + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; + } + state.pipesCount += 1; + debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; + var endFn = doEnd ? onend : unpipe; + if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn); + dest.on('unpipe', onunpipe); + function onunpipe(readable, unpipeInfo) { + debug('onunpipe'); + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + function onend() { + debug('onend'); + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + var cleanedUp = false; + function cleanup() { + debug('cleanup'); + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', unpipe); + src.removeListener('data', ondata); + cleanedUp = true; + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + var ret = dest.write(chunk); + debug('dest.write', ret); + if (ret === false) { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + // => Check whether `dest` is still a piping destination. + if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { + debug('false write response, pause', state.awaitDrain); + state.awaitDrain++; + } + src.pause(); + } + } + + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + debug('onerror', er); + unpipe(); + dest.removeListener('error', onerror); + if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er); + } + + // Make sure our error handler is attached before userland ones. + prependListener(dest, 'error', onerror); + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + debug('onfinish'); + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + function unpipe() { + debug('unpipe'); + src.unpipe(dest); + } + + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + debug('pipe resume'); + src.resume(); + } + return dest; +}; +function pipeOnDrain(src) { + return function pipeOnDrainFunctionResult() { + var state = src._readableState; + debug('pipeOnDrain', state.awaitDrain); + if (state.awaitDrain) state.awaitDrain--; + if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { + state.flowing = true; + flow(src); + } + }; +} +Readable.prototype.unpipe = function (dest) { + var state = this._readableState; + var unpipeInfo = { + hasUnpiped: false + }; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) return this; + if (!dest) dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + if (dest) dest.emit('unpipe', this, unpipeInfo); + return this; + } + + // slow case. multiple pipe destinations. + + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, { + hasUnpiped: false + }); + return this; + } + + // try to find the right one. + var index = indexOf(state.pipes, dest); + if (index === -1) return this; + state.pipes.splice(index, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) state.pipes = state.pipes[0]; + dest.emit('unpipe', this, unpipeInfo); + return this; +}; + +// set up data events if they are asked for +// Ensure readable listeners eventually get something +Readable.prototype.on = function (ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + var state = this._readableState; + if (ev === 'data') { + // update readableListening so that resume() may be a no-op + // a few lines down. This is needed to support once('readable'). + state.readableListening = this.listenerCount('readable') > 0; + + // Try start flowing on next tick if stream isn't explicitly paused + if (state.flowing !== false) this.resume(); + } else if (ev === 'readable') { + if (!state.endEmitted && !state.readableListening) { + state.readableListening = state.needReadable = true; + state.flowing = false; + state.emittedReadable = false; + debug('on readable', state.length, state.reading); + if (state.length) { + emitReadable(this); + } else if (!state.reading) { + process.nextTick(nReadingNextTick, this); + } + } + } + return res; +}; +Readable.prototype.addListener = Readable.prototype.on; +Readable.prototype.removeListener = function (ev, fn) { + var res = Stream.prototype.removeListener.call(this, ev, fn); + if (ev === 'readable') { + // We need to check if there is someone still listening to + // readable and reset the state. However this needs to happen + // after readable has been emitted but before I/O (nextTick) to + // support once('readable', fn) cycles. This means that calling + // resume within the same tick will have no + // effect. + process.nextTick(updateReadableListening, this); + } + return res; +}; +Readable.prototype.removeAllListeners = function (ev) { + var res = Stream.prototype.removeAllListeners.apply(this, arguments); + if (ev === 'readable' || ev === undefined) { + // We need to check if there is someone still listening to + // readable and reset the state. However this needs to happen + // after readable has been emitted but before I/O (nextTick) to + // support once('readable', fn) cycles. This means that calling + // resume within the same tick will have no + // effect. + process.nextTick(updateReadableListening, this); + } + return res; +}; +function updateReadableListening(self) { + var state = self._readableState; + state.readableListening = self.listenerCount('readable') > 0; + if (state.resumeScheduled && !state.paused) { + // flowing needs to be set to true now, otherwise + // the upcoming resume will not flow. + state.flowing = true; + + // crude way to check if we should resume + } else if (self.listenerCount('data') > 0) { + self.resume(); + } +} +function nReadingNextTick(self) { + debug('readable nexttick read 0'); + self.read(0); +} + +// pause() and resume() are remnants of the legacy readable stream API +// If the user uses them, then switch into old mode. +Readable.prototype.resume = function () { + var state = this._readableState; + if (!state.flowing) { + debug('resume'); + // we flow only if there is no one listening + // for readable, but we still have to call + // resume() + state.flowing = !state.readableListening; + resume(this, state); + } + state.paused = false; + return this; +}; +function resume(stream, state) { + if (!state.resumeScheduled) { + state.resumeScheduled = true; + process.nextTick(resume_, stream, state); + } +} +function resume_(stream, state) { + debug('resume', state.reading); + if (!state.reading) { + stream.read(0); + } + state.resumeScheduled = false; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) stream.read(0); +} +Readable.prototype.pause = function () { + debug('call pause flowing=%j', this._readableState.flowing); + if (this._readableState.flowing !== false) { + debug('pause'); + this._readableState.flowing = false; + this.emit('pause'); + } + this._readableState.paused = true; + return this; +}; +function flow(stream) { + var state = stream._readableState; + debug('flow', state.flowing); + while (state.flowing && stream.read() !== null); +} + +// wrap an old-style stream as the async data source. +// This is *not* part of the readable stream interface. +// It is an ugly unfortunate mess of history. +Readable.prototype.wrap = function (stream) { + var _this = this; + var state = this._readableState; + var paused = false; + stream.on('end', function () { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) _this.push(chunk); + } + _this.push(null); + }); + stream.on('data', function (chunk) { + debug('wrapped data'); + if (state.decoder) chunk = state.decoder.write(chunk); + + // don't skip over falsy values in objectMode + if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; + var ret = _this.push(chunk); + if (!ret) { + paused = true; + stream.pause(); + } + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (this[i] === undefined && typeof stream[i] === 'function') { + this[i] = function methodWrap(method) { + return function methodWrapReturnFunction() { + return stream[method].apply(stream, arguments); + }; + }(i); + } + } + + // proxy certain important events. + for (var n = 0; n < kProxyEvents.length; n++) { + stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); + } + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + this._read = function (n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); + } + }; + return this; +}; +if (typeof Symbol === 'function') { + Readable.prototype[Symbol.asyncIterator] = function () { + if (createReadableStreamAsyncIterator === undefined) { + createReadableStreamAsyncIterator = __webpack_require__(9676); + } + return createReadableStreamAsyncIterator(this); + }; +} +Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.highWaterMark; + } +}); +Object.defineProperty(Readable.prototype, 'readableBuffer', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState && this._readableState.buffer; + } +}); +Object.defineProperty(Readable.prototype, 'readableFlowing', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.flowing; + }, + set: function set(state) { + if (this._readableState) { + this._readableState.flowing = state; + } + } +}); + +// exposed for testing purposes only. +Readable._fromList = fromList; +Object.defineProperty(Readable.prototype, 'readableLength', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._readableState.length; + } +}); + +// Pluck off n bytes from an array of buffers. +// Length is the combined lengths of all the buffers in the list. +// This function is designed to be inlinable, so please take care when making +// changes to the function body. +function fromList(n, state) { + // nothing buffered + if (state.length === 0) return null; + var ret; + if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { + // read it all, truncate the list + if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length); + state.buffer.clear(); + } else { + // read part of list + ret = state.buffer.consume(n, state.decoder); + } + return ret; +} +function endReadable(stream) { + var state = stream._readableState; + debug('endReadable', state.endEmitted); + if (!state.endEmitted) { + state.ended = true; + process.nextTick(endReadableNT, state, stream); + } +} +function endReadableNT(state, stream) { + debug('endReadableNT', state.endEmitted, state.length); + + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + if (state.autoDestroy) { + // In case of duplex streams we need a way to detect + // if the writable side is ready for autoDestroy as well + var wState = stream._writableState; + if (!wState || wState.autoDestroy && wState.finished) { + stream.destroy(); + } + } + } +} +if (typeof Symbol === 'function') { + Readable.from = function (iterable, opts) { + if (from === undefined) { + from = __webpack_require__(378); + } + return from(Readable, iterable, opts); + }; +} +function indexOf(xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; +} + +/***/ }, + +/***/ 8569 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// a transform stream is a readable/writable stream where you do +// something with the data. Sometimes it's called a "filter", +// but that's not a great name for it, since that implies a thing where +// some bits pass through, and others are simply ignored. (That would +// be a valid example of a transform, of course.) +// +// While the output is causally related to the input, it's not a +// necessarily symmetric or synchronous transformation. For example, +// a zlib stream might take multiple plain-text writes(), and then +// emit a single compressed chunk some time in the future. +// +// Here's how this works: +// +// The Transform stream has all the aspects of the readable and writable +// stream classes. When you write(chunk), that calls _write(chunk,cb) +// internally, and returns false if there's a lot of pending writes +// buffered up. When you call read(), that calls _read(n) until +// there's enough pending readable data buffered up. +// +// In a transform stream, the written data is placed in a buffer. When +// _read(n) is called, it transforms the queued up data, calling the +// buffered _write cb's as it consumes chunks. If consuming a single +// written chunk would result in multiple output chunks, then the first +// outputted bit calls the readcb, and subsequent chunks just go into +// the read buffer, and will cause it to emit 'readable' if necessary. +// +// This way, back-pressure is actually determined by the reading side, +// since _read has to be called to start processing a new chunk. However, +// a pathological inflate type of transform can cause excessive buffering +// here. For example, imagine a stream where every byte of input is +// interpreted as an integer from 0-255, and then results in that many +// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in +// 1kb of data being output. In this case, you could write a very small +// amount of input, and end up with a very large amount of output. In +// such a pathological inflating mechanism, there'd be no way to tell +// the system to stop doing the transform. A single 4MB write could +// cause the system to run out of memory. +// +// However, even in such a pathological case, only a single written chunk +// would be consumed, and then the rest would wait (un-transformed) until +// the results of the previous transformed chunk were consumed. + + + +module.exports = Transform; +var _require$codes = (__webpack_require__(3797)/* .codes */ .F), + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, + ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, + ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0; +var Duplex = __webpack_require__(4903); +__webpack_require__(9784)(Transform, Duplex); +function afterTransform(er, data) { + var ts = this._transformState; + ts.transforming = false; + var cb = ts.writecb; + if (cb === null) { + return this.emit('error', new ERR_MULTIPLE_CALLBACK()); + } + ts.writechunk = null; + ts.writecb = null; + if (data != null) + // single equals check for both `null` and `undefined` + this.push(data); + cb(er); + var rs = this._readableState; + rs.reading = false; + if (rs.needReadable || rs.length < rs.highWaterMark) { + this._read(rs.highWaterMark); + } +} +function Transform(options) { + if (!(this instanceof Transform)) return new Transform(options); + Duplex.call(this, options); + this._transformState = { + afterTransform: afterTransform.bind(this), + needTransform: false, + transforming: false, + writecb: null, + writechunk: null, + writeencoding: null + }; + + // start out asking for a readable event once data is transformed. + this._readableState.needReadable = true; + + // we have implemented the _read method, and done the other things + // that Readable wants before the first _read call, so unset the + // sync guard flag. + this._readableState.sync = false; + if (options) { + if (typeof options.transform === 'function') this._transform = options.transform; + if (typeof options.flush === 'function') this._flush = options.flush; + } + + // When the writable side finishes, then flush out anything remaining. + this.on('prefinish', prefinish); +} +function prefinish() { + var _this = this; + if (typeof this._flush === 'function' && !this._readableState.destroyed) { + this._flush(function (er, data) { + done(_this, er, data); + }); + } else { + done(this, null, null); + } +} +Transform.prototype.push = function (chunk, encoding) { + this._transformState.needTransform = false; + return Duplex.prototype.push.call(this, chunk, encoding); +}; + +// This is the part where you do stuff! +// override this function in implementation classes. +// 'chunk' is an input chunk. +// +// Call `push(newChunk)` to pass along transformed output +// to the readable side. You may call 'push' zero or more times. +// +// Call `cb(err)` when you are done with this chunk. If you pass +// an error, then that'll put the hurt on the whole operation. If you +// never call cb(), then you'll never get another chunk. +Transform.prototype._transform = function (chunk, encoding, cb) { + cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()')); +}; +Transform.prototype._write = function (chunk, encoding, cb) { + var ts = this._transformState; + ts.writecb = cb; + ts.writechunk = chunk; + ts.writeencoding = encoding; + if (!ts.transforming) { + var rs = this._readableState; + if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark); + } +}; + +// Doesn't matter what the args are here. +// _transform does all the work. +// That we got here means that the readable side wants more data. +Transform.prototype._read = function (n) { + var ts = this._transformState; + if (ts.writechunk !== null && !ts.transforming) { + ts.transforming = true; + this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform); + } else { + // mark that we need a transform, so that any data that comes in + // will get processed, now that we've asked for it. + ts.needTransform = true; + } +}; +Transform.prototype._destroy = function (err, cb) { + Duplex.prototype._destroy.call(this, err, function (err2) { + cb(err2); + }); +}; +function done(stream, er, data) { + if (er) return stream.emit('error', er); + if (data != null) + // single equals check for both `null` and `undefined` + stream.push(data); + + // TODO(BridgeAR): Write a test for these two error cases + // if there's nothing in the write buffer, then that means + // that nothing more will ever be provided + if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0(); + if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING(); + return stream.push(null); +} + +/***/ }, + +/***/ 9781 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +// A bit simpler than readable streams. +// Implement an async ._write(chunk, encoding, cb), and it'll handle all +// the drain event emission and buffering. + + + +module.exports = Writable; + +/* */ +function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; + this.next = null; +} + +// It seems a linked list but it is not +// there will be only 2 of these for each stream +function CorkedRequest(state) { + var _this = this; + this.next = null; + this.entry = null; + this.finish = function () { + onCorkedFinish(_this, state); + }; +} +/* */ + +/**/ +var Duplex; +/**/ + +Writable.WritableState = WritableState; + +/**/ +var internalUtil = { + deprecate: __webpack_require__(6465) +}; +/**/ + +/**/ +var Stream = __webpack_require__(9018); +/**/ + +var Buffer = (__webpack_require__(783).Buffer); +var OurUint8Array = (typeof __webpack_require__.g !== 'undefined' ? __webpack_require__.g : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} +var destroyImpl = __webpack_require__(7385); +var _require = __webpack_require__(8130), + getHighWaterMark = _require.getHighWaterMark; +var _require$codes = (__webpack_require__(3797)/* .codes */ .F), + ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, + ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED, + ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK, + ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE, + ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED, + ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES, + ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END, + ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING; +var errorOrDestroy = destroyImpl.errorOrDestroy; +__webpack_require__(9784)(Writable, Stream); +function nop() {} +function WritableState(options, stream, isDuplex) { + Duplex = Duplex || __webpack_require__(4903); + options = options || {}; + + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream, + // e.g. options.readableObjectMode vs. options.writableObjectMode, etc. + if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); + + // if _final has been called + this.finalCalled = false; + + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // has it been destroyed + this.destroyed = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // when true all writes will be buffered until .uncork() call + this.corked = 0; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function (er) { + onwrite(stream, er); + }; + + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + + // the amount that is being written when _write is called. + this.writelen = 0; + this.bufferedRequest = null; + this.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; + + // emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams + this.prefinished = false; + + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; + + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; + + // Should .destroy() be called after 'finish' (and potentially 'end') + this.autoDestroy = !!options.autoDestroy; + + // count buffered requests + this.bufferedRequestCount = 0; + + // allocate the first CorkedRequest, there is always + // one allocated and free to use, and we maintain at most two + this.corkedRequestsFree = new CorkedRequest(this); +} +WritableState.prototype.getBuffer = function getBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; +}; +(function () { + try { + Object.defineProperty(WritableState.prototype, 'buffer', { + get: internalUtil.deprecate(function writableStateBufferGetter() { + return this.getBuffer(); + }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') + }); + } catch (_) {} +})(); + +// Test _writableState for inheritance to account for Duplex streams, +// whose prototype chain only points to Readable. +var realHasInstance; +if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { + realHasInstance = Function.prototype[Symbol.hasInstance]; + Object.defineProperty(Writable, Symbol.hasInstance, { + value: function value(object) { + if (realHasInstance.call(this, object)) return true; + if (this !== Writable) return false; + return object && object._writableState instanceof WritableState; + } + }); +} else { + realHasInstance = function realHasInstance(object) { + return object instanceof this; + }; +} +function Writable(options) { + Duplex = Duplex || __webpack_require__(4903); + + // Writable ctor is applied to Duplexes, too. + // `realHasInstance` is necessary because using plain `instanceof` + // would return false, as no `_writableState` property is attached. + + // Trying to use the custom `instanceof` for Writable here will also break the + // Node.js LazyTransform implementation, which has a non-trivial getter for + // `_writableState` that would lead to infinite recursion. + + // Checking for a Stream.Duplex instance is faster here instead of inside + // the WritableState constructor, at least with V8 6.5 + var isDuplex = this instanceof Duplex; + if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options); + this._writableState = new WritableState(options, this, isDuplex); + + // legacy. + this.writable = true; + if (options) { + if (typeof options.write === 'function') this._write = options.write; + if (typeof options.writev === 'function') this._writev = options.writev; + if (typeof options.destroy === 'function') this._destroy = options.destroy; + if (typeof options.final === 'function') this._final = options.final; + } + Stream.call(this); +} + +// Otherwise people can pipe Writable streams, which is just wrong. +Writable.prototype.pipe = function () { + errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE()); +}; +function writeAfterEnd(stream, cb) { + var er = new ERR_STREAM_WRITE_AFTER_END(); + // TODO: defer error events consistently everywhere, not just the cb + errorOrDestroy(stream, er); + process.nextTick(cb, er); +} + +// Checks that a user-supplied chunk is valid, especially for the particular +// mode the stream is in. Currently this means that `null` is never accepted +// and undefined/non-string values are only allowed in object mode. +function validChunk(stream, state, chunk, cb) { + var er; + if (chunk === null) { + er = new ERR_STREAM_NULL_VALUES(); + } else if (typeof chunk !== 'string' && !state.objectMode) { + er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk); + } + if (er) { + errorOrDestroy(stream, er); + process.nextTick(cb, er); + return false; + } + return true; +} +Writable.prototype.write = function (chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + var isBuf = !state.objectMode && _isUint8Array(chunk); + if (isBuf && !Buffer.isBuffer(chunk)) { + chunk = _uint8ArrayToBuffer(chunk); + } + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; + if (typeof cb !== 'function') cb = nop; + if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); + } + return ret; +}; +Writable.prototype.cork = function () { + this._writableState.corked++; +}; +Writable.prototype.uncork = function () { + var state = this._writableState; + if (state.corked) { + state.corked--; + if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); + } +}; +Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + // node::ParseEncoding() requires lower case. + if (typeof encoding === 'string') encoding = encoding.toLowerCase(); + if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding); + this._writableState.defaultEncoding = encoding; + return this; +}; +Object.defineProperty(Writable.prototype, 'writableBuffer', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState && this._writableState.getBuffer(); + } +}); +function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { + chunk = Buffer.from(chunk, encoding); + } + return chunk; +} +Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.highWaterMark; + } +}); + +// if we're already writing something, then just put this +// in the queue, and wait our turn. Otherwise, call _write +// If we return false, then we need a drain event, so set that flag. +function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { + if (!isBuf) { + var newChunk = decodeChunk(state, chunk, encoding); + if (chunk !== newChunk) { + isBuf = true; + encoding = 'buffer'; + chunk = newChunk; + } + } + var len = state.objectMode ? 1 : chunk.length; + state.length += len; + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) state.needDrain = true; + if (state.writing || state.corked) { + var last = state.lastBufferedRequest; + state.lastBufferedRequest = { + chunk: chunk, + encoding: encoding, + isBuf: isBuf, + callback: cb, + next: null + }; + if (last) { + last.next = state.lastBufferedRequest; + } else { + state.bufferedRequest = state.lastBufferedRequest; + } + state.bufferedRequestCount += 1; + } else { + doWrite(stream, state, false, len, chunk, encoding, cb); + } + return ret; +} +function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); + state.sync = false; +} +function onwriteError(stream, state, sync, er, cb) { + --state.pendingcb; + if (sync) { + // defer the callback if we are being called synchronously + // to avoid piling up things on the stack + process.nextTick(cb, er); + // this can emit finish, and it will always happen + // after error + process.nextTick(finishMaybe, stream, state); + stream._writableState.errorEmitted = true; + errorOrDestroy(stream, er); + } else { + // the caller expect this to happen before if + // it is async + cb(er); + stream._writableState.errorEmitted = true; + errorOrDestroy(stream, er); + // this can emit finish, but finish must + // always follow error + finishMaybe(stream, state); + } +} +function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; +} +function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK(); + onwriteStateUpdate(state); + if (er) onwriteError(stream, state, sync, er, cb);else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(state) || stream.destroyed; + if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { + clearBuffer(stream, state); + } + if (sync) { + process.nextTick(afterWrite, stream, state, finished, cb); + } else { + afterWrite(stream, state, finished, cb); + } + } +} +function afterWrite(stream, state, finished, cb) { + if (!finished) onwriteDrain(stream, state); + state.pendingcb--; + cb(); + finishMaybe(stream, state); +} + +// Must force callback to be called on nextTick, so that we don't +// emit 'drain' before the write() consumer gets the 'false' return +// value, and has a chance to attach a 'drain' listener. +function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } +} + +// if there's something in the buffer waiting, then process it +function clearBuffer(stream, state) { + state.bufferProcessing = true; + var entry = state.bufferedRequest; + if (stream._writev && entry && entry.next) { + // Fast case, write everything using _writev() + var l = state.bufferedRequestCount; + var buffer = new Array(l); + var holder = state.corkedRequestsFree; + holder.entry = entry; + var count = 0; + var allBuffers = true; + while (entry) { + buffer[count] = entry; + if (!entry.isBuf) allBuffers = false; + entry = entry.next; + count += 1; + } + buffer.allBuffers = allBuffers; + doWrite(stream, state, true, state.length, buffer, '', holder.finish); + + // doWrite is almost always async, defer these to save a bit of time + // as the hot path ends with doWrite + state.pendingcb++; + state.lastBufferedRequest = null; + if (holder.next) { + state.corkedRequestsFree = holder.next; + holder.next = null; + } else { + state.corkedRequestsFree = new CorkedRequest(state); + } + state.bufferedRequestCount = 0; + } else { + // Slow case, write chunks one-by-one + while (entry) { + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + doWrite(stream, state, false, len, chunk, encoding, cb); + entry = entry.next; + state.bufferedRequestCount--; + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + break; + } + } + if (entry === null) state.lastBufferedRequest = null; + } + state.bufferedRequest = entry; + state.bufferProcessing = false; +} +Writable.prototype._write = function (chunk, encoding, cb) { + cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()')); +}; +Writable.prototype._writev = null; +Writable.prototype.end = function (chunk, encoding, cb) { + var state = this._writableState; + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); + + // .end() fully uncorks + if (state.corked) { + state.corked = 1; + this.uncork(); + } + + // ignore unnecessary end() calls. + if (!state.ending) endWritable(this, state, cb); + return this; +}; +Object.defineProperty(Writable.prototype, 'writableLength', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + return this._writableState.length; + } +}); +function needFinish(state) { + return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; +} +function callFinal(stream, state) { + stream._final(function (err) { + state.pendingcb--; + if (err) { + errorOrDestroy(stream, err); + } + state.prefinished = true; + stream.emit('prefinish'); + finishMaybe(stream, state); + }); +} +function prefinish(stream, state) { + if (!state.prefinished && !state.finalCalled) { + if (typeof stream._final === 'function' && !state.destroyed) { + state.pendingcb++; + state.finalCalled = true; + process.nextTick(callFinal, stream, state); + } else { + state.prefinished = true; + stream.emit('prefinish'); + } + } +} +function finishMaybe(stream, state) { + var need = needFinish(state); + if (need) { + prefinish(stream, state); + if (state.pendingcb === 0) { + state.finished = true; + stream.emit('finish'); + if (state.autoDestroy) { + // In case of duplex streams we need a way to detect + // if the readable side is ready for autoDestroy as well + var rState = stream._readableState; + if (!rState || rState.autoDestroy && rState.endEmitted) { + stream.destroy(); + } + } + } + } + return need; +} +function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) process.nextTick(cb);else stream.once('finish', cb); + } + state.ended = true; + stream.writable = false; +} +function onCorkedFinish(corkReq, state, err) { + var entry = corkReq.entry; + corkReq.entry = null; + while (entry) { + var cb = entry.callback; + state.pendingcb--; + cb(err); + entry = entry.next; + } + + // reuse the free corkReq. + state.corkedRequestsFree.next = corkReq; +} +Object.defineProperty(Writable.prototype, 'destroyed', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function get() { + if (this._writableState === undefined) { + return false; + } + return this._writableState.destroyed; + }, + set: function set(value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._writableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._writableState.destroyed = value; + } +}); +Writable.prototype.destroy = destroyImpl.destroy; +Writable.prototype._undestroy = destroyImpl.undestroy; +Writable.prototype._destroy = function (err, cb) { + cb(err); +}; + +/***/ }, + +/***/ 9676 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); + + +var _Object$setPrototypeO; +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } +var finished = __webpack_require__(2167); +var kLastResolve = Symbol('lastResolve'); +var kLastReject = Symbol('lastReject'); +var kError = Symbol('error'); +var kEnded = Symbol('ended'); +var kLastPromise = Symbol('lastPromise'); +var kHandlePromise = Symbol('handlePromise'); +var kStream = Symbol('stream'); +function createIterResult(value, done) { + return { + value: value, + done: done + }; +} +function readAndResolve(iter) { + var resolve = iter[kLastResolve]; + if (resolve !== null) { + var data = iter[kStream].read(); + // we defer if data is null + // we can be expecting either 'end' or + // 'error' + if (data !== null) { + iter[kLastPromise] = null; + iter[kLastResolve] = null; + iter[kLastReject] = null; + resolve(createIterResult(data, false)); + } + } +} +function onReadable(iter) { + // we wait for the next tick, because it might + // emit an error with process.nextTick + process.nextTick(readAndResolve, iter); +} +function wrapForNext(lastPromise, iter) { + return function (resolve, reject) { + lastPromise.then(function () { + if (iter[kEnded]) { + resolve(createIterResult(undefined, true)); + return; + } + iter[kHandlePromise](resolve, reject); + }, reject); + }; +} +var AsyncIteratorPrototype = Object.getPrototypeOf(function () {}); +var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = { + get stream() { + return this[kStream]; + }, + next: function next() { + var _this = this; + // if we have detected an error in the meanwhile + // reject straight away + var error = this[kError]; + if (error !== null) { + return Promise.reject(error); + } + if (this[kEnded]) { + return Promise.resolve(createIterResult(undefined, true)); + } + if (this[kStream].destroyed) { + // We need to defer via nextTick because if .destroy(err) is + // called, the error will be emitted via nextTick, and + // we cannot guarantee that there is no error lingering around + // waiting to be emitted. + return new Promise(function (resolve, reject) { + process.nextTick(function () { + if (_this[kError]) { + reject(_this[kError]); + } else { + resolve(createIterResult(undefined, true)); + } + }); + }); + } + + // if we have multiple next() calls + // we will wait for the previous Promise to finish + // this logic is optimized to support for await loops, + // where next() is only called once at a time + var lastPromise = this[kLastPromise]; + var promise; + if (lastPromise) { + promise = new Promise(wrapForNext(lastPromise, this)); + } else { + // fast path needed to support multiple this.push() + // without triggering the next() queue + var data = this[kStream].read(); + if (data !== null) { + return Promise.resolve(createIterResult(data, false)); + } + promise = new Promise(this[kHandlePromise]); + } + this[kLastPromise] = promise; + return promise; + } +}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () { + return this; +}), _defineProperty(_Object$setPrototypeO, "return", function _return() { + var _this2 = this; + // destroy(err, cb) is a private API + // we can guarantee we have that here, because we control the + // Readable class this is attached to + return new Promise(function (resolve, reject) { + _this2[kStream].destroy(null, function (err) { + if (err) { + reject(err); + return; + } + resolve(createIterResult(undefined, true)); + }); + }); +}), _Object$setPrototypeO), AsyncIteratorPrototype); +var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) { + var _Object$create; + var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, { + value: stream, + writable: true + }), _defineProperty(_Object$create, kLastResolve, { + value: null, + writable: true + }), _defineProperty(_Object$create, kLastReject, { + value: null, + writable: true + }), _defineProperty(_Object$create, kError, { + value: null, + writable: true + }), _defineProperty(_Object$create, kEnded, { + value: stream._readableState.endEmitted, + writable: true + }), _defineProperty(_Object$create, kHandlePromise, { + value: function value(resolve, reject) { + var data = iterator[kStream].read(); + if (data) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + resolve(createIterResult(data, false)); + } else { + iterator[kLastResolve] = resolve; + iterator[kLastReject] = reject; + } + }, + writable: true + }), _Object$create)); + iterator[kLastPromise] = null; + finished(stream, function (err) { + if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + var reject = iterator[kLastReject]; + // reject if we are waiting for data in the Promise + // returned by next() and store the error + if (reject !== null) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + reject(err); + } + iterator[kError] = err; + return; + } + var resolve = iterator[kLastResolve]; + if (resolve !== null) { + iterator[kLastPromise] = null; + iterator[kLastResolve] = null; + iterator[kLastReject] = null; + resolve(createIterResult(undefined, true)); + } + iterator[kEnded] = true; + }); + stream.on('readable', onReadable.bind(null, iterator)); + return iterator; +}; +module.exports = createReadableStreamAsyncIterator; + +/***/ }, + +/***/ 7385 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var process = __webpack_require__(9964); + + +// undocumented cb() API, needed for core, not for public API +function destroy(err, cb) { + var _this = this; + var readableDestroyed = this._readableState && this._readableState.destroyed; + var writableDestroyed = this._writableState && this._writableState.destroyed; + if (readableDestroyed || writableDestroyed) { + if (cb) { + cb(err); + } else if (err) { + if (!this._writableState) { + process.nextTick(emitErrorNT, this, err); + } else if (!this._writableState.errorEmitted) { + this._writableState.errorEmitted = true; + process.nextTick(emitErrorNT, this, err); + } + } + return this; + } + + // we set destroyed to true before firing error callbacks in order + // to make it re-entrance safe in case destroy() is called within callbacks + + if (this._readableState) { + this._readableState.destroyed = true; + } + + // if this is a duplex stream mark the writable part as destroyed as well + if (this._writableState) { + this._writableState.destroyed = true; + } + this._destroy(err || null, function (err) { + if (!cb && err) { + if (!_this._writableState) { + process.nextTick(emitErrorAndCloseNT, _this, err); + } else if (!_this._writableState.errorEmitted) { + _this._writableState.errorEmitted = true; + process.nextTick(emitErrorAndCloseNT, _this, err); + } else { + process.nextTick(emitCloseNT, _this); + } + } else if (cb) { + process.nextTick(emitCloseNT, _this); + cb(err); + } else { + process.nextTick(emitCloseNT, _this); + } + }); + return this; +} +function emitErrorAndCloseNT(self, err) { + emitErrorNT(self, err); + emitCloseNT(self); +} +function emitCloseNT(self) { + if (self._writableState && !self._writableState.emitClose) return; + if (self._readableState && !self._readableState.emitClose) return; + self.emit('close'); +} +function undestroy() { + if (this._readableState) { + this._readableState.destroyed = false; + this._readableState.reading = false; + this._readableState.ended = false; + this._readableState.endEmitted = false; + } + if (this._writableState) { + this._writableState.destroyed = false; + this._writableState.ended = false; + this._writableState.ending = false; + this._writableState.finalCalled = false; + this._writableState.prefinished = false; + this._writableState.finished = false; + this._writableState.errorEmitted = false; + } +} +function emitErrorNT(self, err) { + self.emit('error', err); +} +function errorOrDestroy(stream, err) { + // We have tests that rely on errors being emitted + // in the same tick, so changing this is semver major. + // For now when you opt-in to autoDestroy we allow + // the error to be emitted nextTick. In a future + // semver major update we should change the default to this. + + var rState = stream._readableState; + var wState = stream._writableState; + if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err); +} +module.exports = { + destroy: destroy, + undestroy: undestroy, + errorOrDestroy: errorOrDestroy +}; + +/***/ }, + +/***/ 2167 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +// Ported from https://github.com/mafintosh/end-of-stream with +// permission from the author, Mathias Buus (@mafintosh). + + + +var ERR_STREAM_PREMATURE_CLOSE = (__webpack_require__(3797)/* .codes */ .F).ERR_STREAM_PREMATURE_CLOSE; +function once(callback) { + var called = false; + return function () { + if (called) return; + called = true; + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + callback.apply(this, args); + }; +} +function noop() {} +function isRequest(stream) { + return stream.setHeader && typeof stream.abort === 'function'; +} +function eos(stream, opts, callback) { + if (typeof opts === 'function') return eos(stream, null, opts); + if (!opts) opts = {}; + callback = once(callback || noop); + var readable = opts.readable || opts.readable !== false && stream.readable; + var writable = opts.writable || opts.writable !== false && stream.writable; + var onlegacyfinish = function onlegacyfinish() { + if (!stream.writable) onfinish(); + }; + var writableEnded = stream._writableState && stream._writableState.finished; + var onfinish = function onfinish() { + writable = false; + writableEnded = true; + if (!readable) callback.call(stream); + }; + var readableEnded = stream._readableState && stream._readableState.endEmitted; + var onend = function onend() { + readable = false; + readableEnded = true; + if (!writable) callback.call(stream); + }; + var onerror = function onerror(err) { + callback.call(stream, err); + }; + var onclose = function onclose() { + var err; + if (readable && !readableEnded) { + if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); + return callback.call(stream, err); + } + if (writable && !writableEnded) { + if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE(); + return callback.call(stream, err); + } + }; + var onrequest = function onrequest() { + stream.req.on('finish', onfinish); + }; + if (isRequest(stream)) { + stream.on('complete', onfinish); + stream.on('abort', onclose); + if (stream.req) onrequest();else stream.on('request', onrequest); + } else if (writable && !stream._writableState) { + // legacy streams + stream.on('end', onlegacyfinish); + stream.on('close', onlegacyfinish); + } + stream.on('end', onend); + stream.on('finish', onfinish); + if (opts.error !== false) stream.on('error', onerror); + stream.on('close', onclose); + return function () { + stream.removeListener('complete', onfinish); + stream.removeListener('abort', onclose); + stream.removeListener('request', onrequest); + if (stream.req) stream.req.removeListener('finish', onfinish); + stream.removeListener('end', onlegacyfinish); + stream.removeListener('close', onlegacyfinish); + stream.removeListener('finish', onfinish); + stream.removeListener('end', onend); + stream.removeListener('error', onerror); + stream.removeListener('close', onclose); + }; +} +module.exports = eos; + +/***/ }, + +/***/ 378 +(module) { + +module.exports = function () { + throw new Error('Readable.from is not available in the browser') +}; + + +/***/ }, + +/***/ 3765 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +// Ported from https://github.com/mafintosh/pump with +// permission from the author, Mathias Buus (@mafintosh). + + + +var eos; +function once(callback) { + var called = false; + return function () { + if (called) return; + called = true; + callback.apply(void 0, arguments); + }; +} +var _require$codes = (__webpack_require__(3797)/* .codes */ .F), + ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, + ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; +function noop(err) { + // Rethrow the error if it exists to avoid swallowing it + if (err) throw err; +} +function isRequest(stream) { + return stream.setHeader && typeof stream.abort === 'function'; +} +function destroyer(stream, reading, writing, callback) { + callback = once(callback); + var closed = false; + stream.on('close', function () { + closed = true; + }); + if (eos === undefined) eos = __webpack_require__(2167); + eos(stream, { + readable: reading, + writable: writing + }, function (err) { + if (err) return callback(err); + closed = true; + callback(); + }); + var destroyed = false; + return function (err) { + if (closed) return; + if (destroyed) return; + destroyed = true; + + // request.destroy just do .end - .abort is what we want + if (isRequest(stream)) return stream.abort(); + if (typeof stream.destroy === 'function') return stream.destroy(); + callback(err || new ERR_STREAM_DESTROYED('pipe')); + }; +} +function call(fn) { + fn(); +} +function pipe(from, to) { + return from.pipe(to); +} +function popCallback(streams) { + if (!streams.length) return noop; + if (typeof streams[streams.length - 1] !== 'function') return noop; + return streams.pop(); +} +function pipeline() { + for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) { + streams[_key] = arguments[_key]; + } + var callback = popCallback(streams); + if (Array.isArray(streams[0])) streams = streams[0]; + if (streams.length < 2) { + throw new ERR_MISSING_ARGS('streams'); + } + var error; + var destroys = streams.map(function (stream, i) { + var reading = i < streams.length - 1; + var writing = i > 0; + return destroyer(stream, reading, writing, function (err) { + if (!error) error = err; + if (err) destroys.forEach(call); + if (reading) return; + destroys.forEach(call); + callback(error); + }); + }); + return streams.reduce(pipe); +} +module.exports = pipeline; + +/***/ }, + +/***/ 8130 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var ERR_INVALID_OPT_VALUE = (__webpack_require__(3797)/* .codes */ .F).ERR_INVALID_OPT_VALUE; +function highWaterMarkFrom(options, isDuplex, duplexKey) { + return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null; +} +function getHighWaterMark(state, options, duplexKey, isDuplex) { + var hwm = highWaterMarkFrom(options, isDuplex, duplexKey); + if (hwm != null) { + if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) { + var name = isDuplex ? duplexKey : 'highWaterMark'; + throw new ERR_INVALID_OPT_VALUE(name, hwm); + } + return Math.floor(hwm); + } + + // Default value + return state.objectMode ? 16 : 16 * 1024; +} +module.exports = { + getHighWaterMark: getHighWaterMark +}; + +/***/ }, + +/***/ 9018 +(module, __unused_webpack_exports, __webpack_require__) { + +module.exports = __webpack_require__(4785).EventEmitter; + + +/***/ }, + +/***/ 3143 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +/**/ + +var Buffer = (__webpack_require__(5691).Buffer); +/**/ + +var isEncoding = Buffer.isEncoding || function (encoding) { + encoding = '' + encoding; + switch (encoding && encoding.toLowerCase()) { + case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw': + return true; + default: + return false; + } +}; + +function _normalizeEncoding(enc) { + if (!enc) return 'utf8'; + var retried; + while (true) { + switch (enc) { + case 'utf8': + case 'utf-8': + return 'utf8'; + case 'ucs2': + case 'ucs-2': + case 'utf16le': + case 'utf-16le': + return 'utf16le'; + case 'latin1': + case 'binary': + return 'latin1'; + case 'base64': + case 'ascii': + case 'hex': + return enc; + default: + if (retried) return; // undefined + enc = ('' + enc).toLowerCase(); + retried = true; + } + } +}; + +// Do not cache `Buffer.isEncoding` when checking encoding names as some +// modules monkey-patch it to support additional encodings +function normalizeEncoding(enc) { + var nenc = _normalizeEncoding(enc); + if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc); + return nenc || enc; +} + +// StringDecoder provides an interface for efficiently splitting a series of +// buffers into a series of JS strings without breaking apart multi-byte +// characters. +exports.I = StringDecoder; +function StringDecoder(encoding) { + this.encoding = normalizeEncoding(encoding); + var nb; + switch (this.encoding) { + case 'utf16le': + this.text = utf16Text; + this.end = utf16End; + nb = 4; + break; + case 'utf8': + this.fillLast = utf8FillLast; + nb = 4; + break; + case 'base64': + this.text = base64Text; + this.end = base64End; + nb = 3; + break; + default: + this.write = simpleWrite; + this.end = simpleEnd; + return; + } + this.lastNeed = 0; + this.lastTotal = 0; + this.lastChar = Buffer.allocUnsafe(nb); +} + +StringDecoder.prototype.write = function (buf) { + if (buf.length === 0) return ''; + var r; + var i; + if (this.lastNeed) { + r = this.fillLast(buf); + if (r === undefined) return ''; + i = this.lastNeed; + this.lastNeed = 0; + } else { + i = 0; + } + if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i); + return r || ''; +}; + +StringDecoder.prototype.end = utf8End; + +// Returns only complete characters in a Buffer +StringDecoder.prototype.text = utf8Text; + +// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer +StringDecoder.prototype.fillLast = function (buf) { + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length); + this.lastNeed -= buf.length; +}; + +// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a +// continuation byte. If an invalid byte is detected, -2 is returned. +function utf8CheckByte(byte) { + if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4; + return byte >> 6 === 0x02 ? -1 : -2; +} + +// Checks at most 3 bytes at the end of a Buffer in order to detect an +// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4) +// needed to complete the UTF-8 character (if applicable) are returned. +function utf8CheckIncomplete(self, buf, i) { + var j = buf.length - 1; + if (j < i) return 0; + var nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 1; + return nb; + } + if (--j < i || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) self.lastNeed = nb - 2; + return nb; + } + if (--j < i || nb === -2) return 0; + nb = utf8CheckByte(buf[j]); + if (nb >= 0) { + if (nb > 0) { + if (nb === 2) nb = 0;else self.lastNeed = nb - 3; + } + return nb; + } + return 0; +} + +// Validates as many continuation bytes for a multi-byte UTF-8 character as +// needed or are available. If we see a non-continuation byte where we expect +// one, we "replace" the validated continuation bytes we've seen so far with +// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding +// behavior. The continuation byte check is included three times in the case +// where all of the continuation bytes for a character exist in the same buffer. +// It is also done this way as a slight performance increase instead of using a +// loop. +function utf8CheckExtraBytes(self, buf, p) { + if ((buf[0] & 0xC0) !== 0x80) { + self.lastNeed = 0; + return '\ufffd'; + } + if (self.lastNeed > 1 && buf.length > 1) { + if ((buf[1] & 0xC0) !== 0x80) { + self.lastNeed = 1; + return '\ufffd'; + } + if (self.lastNeed > 2 && buf.length > 2) { + if ((buf[2] & 0xC0) !== 0x80) { + self.lastNeed = 2; + return '\ufffd'; + } + } + } +} + +// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer. +function utf8FillLast(buf) { + var p = this.lastTotal - this.lastNeed; + var r = utf8CheckExtraBytes(this, buf, p); + if (r !== undefined) return r; + if (this.lastNeed <= buf.length) { + buf.copy(this.lastChar, p, 0, this.lastNeed); + return this.lastChar.toString(this.encoding, 0, this.lastTotal); + } + buf.copy(this.lastChar, p, 0, buf.length); + this.lastNeed -= buf.length; +} + +// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a +// partial character, the character's bytes are buffered until the required +// number of bytes are available. +function utf8Text(buf, i) { + var total = utf8CheckIncomplete(this, buf, i); + if (!this.lastNeed) return buf.toString('utf8', i); + this.lastTotal = total; + var end = buf.length - (total - this.lastNeed); + buf.copy(this.lastChar, 0, end); + return buf.toString('utf8', i, end); +} + +// For UTF-8, a replacement character is added when ending on a partial +// character. +function utf8End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + '\ufffd'; + return r; +} + +// UTF-16LE typically needs two bytes per character, but even if we have an even +// number of bytes available, we need to check if we end on a leading/high +// surrogate. In that case, we need to wait for the next two bytes in order to +// decode the last character properly. +function utf16Text(buf, i) { + if ((buf.length - i) % 2 === 0) { + var r = buf.toString('utf16le', i); + if (r) { + var c = r.charCodeAt(r.length - 1); + if (c >= 0xD800 && c <= 0xDBFF) { + this.lastNeed = 2; + this.lastTotal = 4; + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + return r.slice(0, -1); + } + } + return r; + } + this.lastNeed = 1; + this.lastTotal = 2; + this.lastChar[0] = buf[buf.length - 1]; + return buf.toString('utf16le', i, buf.length - 1); +} + +// For UTF-16LE we do not explicitly append special replacement characters if we +// end on a partial character, we simply let v8 handle that. +function utf16End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) { + var end = this.lastTotal - this.lastNeed; + return r + this.lastChar.toString('utf16le', 0, end); + } + return r; +} + +function base64Text(buf, i) { + var n = (buf.length - i) % 3; + if (n === 0) return buf.toString('base64', i); + this.lastNeed = 3 - n; + this.lastTotal = 3; + if (n === 1) { + this.lastChar[0] = buf[buf.length - 1]; + } else { + this.lastChar[0] = buf[buf.length - 2]; + this.lastChar[1] = buf[buf.length - 1]; + } + return buf.toString('base64', i, buf.length - n); +} + +function base64End(buf) { + var r = buf && buf.length ? this.write(buf) : ''; + if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed); + return r; +} + +// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex) +function simpleWrite(buf) { + return buf.toString(this.encoding); +} + +function simpleEnd(buf) { + return buf && buf.length ? this.write(buf) : ''; +} + +/***/ }, + +/***/ 3483 +(module) { + +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; + + +/***/ }, + +/***/ 6465 +(module, __unused_webpack_exports, __webpack_require__) { + + +/** + * Module exports. + */ + +module.exports = deprecate; + +/** + * Mark that a method should not be used. + * Returns a modified function which warns once by default. + * + * If `localStorage.noDeprecation = true` is set, then it is a no-op. + * + * If `localStorage.throwDeprecation = true` is set, then deprecated functions + * will throw an Error when invoked. + * + * If `localStorage.traceDeprecation = true` is set, then deprecated functions + * will invoke `console.trace()` instead of `console.error()`. + * + * @param {Function} fn - the function to deprecate + * @param {String} msg - the string to print to the console when `fn` is invoked + * @returns {Function} a new "deprecated" version of `fn` + * @api public + */ + +function deprecate (fn, msg) { + if (config('noDeprecation')) { + return fn; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (config('throwDeprecation')) { + throw new Error(msg); + } else if (config('traceDeprecation')) { + console.trace(msg); + } else { + console.warn(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +} + +/** + * Checks `localStorage` for boolean values for the given `name`. + * + * @param {String} name + * @returns {Boolean} + * @api private + */ + +function config (name) { + // accessing global.localStorage can trigger a DOMException in sandboxed iframes + try { + if (!__webpack_require__.g.localStorage) return false; + } catch (_) { + return false; + } + var val = __webpack_require__.g.localStorage[name]; + if (null == val) return false; + return String(val).toLowerCase() === 'true'; +} + + +/***/ }, + +/***/ 1201 +(module) { + +module.exports = function isBuffer(arg) { + return arg && typeof arg === 'object' + && typeof arg.copy === 'function' + && typeof arg.fill === 'function' + && typeof arg.readUInt8 === 'function'; +} + +/***/ }, + +/***/ 9490 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +// Currently in sync with Node.js lib/internal/util/types.js +// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9 + + + +var isArgumentsObject = __webpack_require__(7906); +var isGeneratorFunction = __webpack_require__(4610); +var whichTypedArray = __webpack_require__(3381); +var isTypedArray = __webpack_require__(6094); + +function uncurryThis(f) { + return f.call.bind(f); +} + +var BigIntSupported = typeof BigInt !== 'undefined'; +var SymbolSupported = typeof Symbol !== 'undefined'; + +var ObjectToString = uncurryThis(Object.prototype.toString); + +var numberValue = uncurryThis(Number.prototype.valueOf); +var stringValue = uncurryThis(String.prototype.valueOf); +var booleanValue = uncurryThis(Boolean.prototype.valueOf); + +if (BigIntSupported) { + var bigIntValue = uncurryThis(BigInt.prototype.valueOf); +} + +if (SymbolSupported) { + var symbolValue = uncurryThis(Symbol.prototype.valueOf); +} + +function checkBoxedPrimitive(value, prototypeValueOf) { + if (typeof value !== 'object') { + return false; + } + try { + prototypeValueOf(value); + return true; + } catch(e) { + return false; + } +} + +exports.isArgumentsObject = isArgumentsObject; +exports.isGeneratorFunction = isGeneratorFunction; +exports.isTypedArray = isTypedArray; + +// Taken from here and modified for better browser support +// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js +function isPromise(input) { + return ( + ( + typeof Promise !== 'undefined' && + input instanceof Promise + ) || + ( + input !== null && + typeof input === 'object' && + typeof input.then === 'function' && + typeof input.catch === 'function' + ) + ); +} +exports.isPromise = isPromise; + +function isArrayBufferView(value) { + if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) { + return ArrayBuffer.isView(value); + } + + return ( + isTypedArray(value) || + isDataView(value) + ); +} +exports.isArrayBufferView = isArrayBufferView; + + +function isUint8Array(value) { + return whichTypedArray(value) === 'Uint8Array'; +} +exports.isUint8Array = isUint8Array; + +function isUint8ClampedArray(value) { + return whichTypedArray(value) === 'Uint8ClampedArray'; +} +exports.isUint8ClampedArray = isUint8ClampedArray; + +function isUint16Array(value) { + return whichTypedArray(value) === 'Uint16Array'; +} +exports.isUint16Array = isUint16Array; + +function isUint32Array(value) { + return whichTypedArray(value) === 'Uint32Array'; +} +exports.isUint32Array = isUint32Array; + +function isInt8Array(value) { + return whichTypedArray(value) === 'Int8Array'; +} +exports.isInt8Array = isInt8Array; + +function isInt16Array(value) { + return whichTypedArray(value) === 'Int16Array'; +} +exports.isInt16Array = isInt16Array; + +function isInt32Array(value) { + return whichTypedArray(value) === 'Int32Array'; +} +exports.isInt32Array = isInt32Array; + +function isFloat32Array(value) { + return whichTypedArray(value) === 'Float32Array'; +} +exports.isFloat32Array = isFloat32Array; + +function isFloat64Array(value) { + return whichTypedArray(value) === 'Float64Array'; +} +exports.isFloat64Array = isFloat64Array; + +function isBigInt64Array(value) { + return whichTypedArray(value) === 'BigInt64Array'; +} +exports.isBigInt64Array = isBigInt64Array; + +function isBigUint64Array(value) { + return whichTypedArray(value) === 'BigUint64Array'; +} +exports.isBigUint64Array = isBigUint64Array; + +function isMapToString(value) { + return ObjectToString(value) === '[object Map]'; +} +isMapToString.working = ( + typeof Map !== 'undefined' && + isMapToString(new Map()) +); + +function isMap(value) { + if (typeof Map === 'undefined') { + return false; + } + + return isMapToString.working + ? isMapToString(value) + : value instanceof Map; +} +exports.isMap = isMap; + +function isSetToString(value) { + return ObjectToString(value) === '[object Set]'; +} +isSetToString.working = ( + typeof Set !== 'undefined' && + isSetToString(new Set()) +); +function isSet(value) { + if (typeof Set === 'undefined') { + return false; + } + + return isSetToString.working + ? isSetToString(value) + : value instanceof Set; +} +exports.isSet = isSet; + +function isWeakMapToString(value) { + return ObjectToString(value) === '[object WeakMap]'; +} +isWeakMapToString.working = ( + typeof WeakMap !== 'undefined' && + isWeakMapToString(new WeakMap()) +); +function isWeakMap(value) { + if (typeof WeakMap === 'undefined') { + return false; + } + + return isWeakMapToString.working + ? isWeakMapToString(value) + : value instanceof WeakMap; +} +exports.isWeakMap = isWeakMap; + +function isWeakSetToString(value) { + return ObjectToString(value) === '[object WeakSet]'; +} +isWeakSetToString.working = ( + typeof WeakSet !== 'undefined' && + isWeakSetToString(new WeakSet()) +); +function isWeakSet(value) { + return isWeakSetToString(value); +} +exports.isWeakSet = isWeakSet; + +function isArrayBufferToString(value) { + return ObjectToString(value) === '[object ArrayBuffer]'; +} +isArrayBufferToString.working = ( + typeof ArrayBuffer !== 'undefined' && + isArrayBufferToString(new ArrayBuffer()) +); +function isArrayBuffer(value) { + if (typeof ArrayBuffer === 'undefined') { + return false; + } + + return isArrayBufferToString.working + ? isArrayBufferToString(value) + : value instanceof ArrayBuffer; +} +exports.isArrayBuffer = isArrayBuffer; + +function isDataViewToString(value) { + return ObjectToString(value) === '[object DataView]'; +} +isDataViewToString.working = ( + typeof ArrayBuffer !== 'undefined' && + typeof DataView !== 'undefined' && + isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1)) +); +function isDataView(value) { + if (typeof DataView === 'undefined') { + return false; + } + + return isDataViewToString.working + ? isDataViewToString(value) + : value instanceof DataView; +} +exports.isDataView = isDataView; + +// Store a copy of SharedArrayBuffer in case it's deleted elsewhere +var SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined; +function isSharedArrayBufferToString(value) { + return ObjectToString(value) === '[object SharedArrayBuffer]'; +} +function isSharedArrayBuffer(value) { + if (typeof SharedArrayBufferCopy === 'undefined') { + return false; + } + + if (typeof isSharedArrayBufferToString.working === 'undefined') { + isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy()); + } + + return isSharedArrayBufferToString.working + ? isSharedArrayBufferToString(value) + : value instanceof SharedArrayBufferCopy; +} +exports.isSharedArrayBuffer = isSharedArrayBuffer; + +function isAsyncFunction(value) { + return ObjectToString(value) === '[object AsyncFunction]'; +} +exports.isAsyncFunction = isAsyncFunction; + +function isMapIterator(value) { + return ObjectToString(value) === '[object Map Iterator]'; +} +exports.isMapIterator = isMapIterator; + +function isSetIterator(value) { + return ObjectToString(value) === '[object Set Iterator]'; +} +exports.isSetIterator = isSetIterator; + +function isGeneratorObject(value) { + return ObjectToString(value) === '[object Generator]'; +} +exports.isGeneratorObject = isGeneratorObject; + +function isWebAssemblyCompiledModule(value) { + return ObjectToString(value) === '[object WebAssembly.Module]'; +} +exports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule; + +function isNumberObject(value) { + return checkBoxedPrimitive(value, numberValue); +} +exports.isNumberObject = isNumberObject; + +function isStringObject(value) { + return checkBoxedPrimitive(value, stringValue); +} +exports.isStringObject = isStringObject; + +function isBooleanObject(value) { + return checkBoxedPrimitive(value, booleanValue); +} +exports.isBooleanObject = isBooleanObject; + +function isBigIntObject(value) { + return BigIntSupported && checkBoxedPrimitive(value, bigIntValue); +} +exports.isBigIntObject = isBigIntObject; + +function isSymbolObject(value) { + return SymbolSupported && checkBoxedPrimitive(value, symbolValue); +} +exports.isSymbolObject = isSymbolObject; + +function isBoxedPrimitive(value) { + return ( + isNumberObject(value) || + isStringObject(value) || + isBooleanObject(value) || + isBigIntObject(value) || + isSymbolObject(value) + ); +} +exports.isBoxedPrimitive = isBoxedPrimitive; + +function isAnyArrayBuffer(value) { + return typeof Uint8Array !== 'undefined' && ( + isArrayBuffer(value) || + isSharedArrayBuffer(value) + ); +} +exports.isAnyArrayBuffer = isAnyArrayBuffer; + +['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) { + Object.defineProperty(exports, method, { + enumerable: false, + value: function() { + throw new Error(method + ' is not supported in userland'); + } + }); +}); + + +/***/ }, + +/***/ 7187 +(__unused_webpack_module, exports, __webpack_require__) { + +/* provided dependency */ var process = __webpack_require__(9964); +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || + function getOwnPropertyDescriptors(obj) { + var keys = Object.keys(obj); + var descriptors = {}; + for (var i = 0; i < keys.length; i++) { + descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]); + } + return descriptors; + }; + +var formatRegExp = /%[sdj%]/g; +exports.format = function(f) { + if (!isString(f)) { + var objects = []; + for (var i = 0; i < arguments.length; i++) { + objects.push(inspect(arguments[i])); + } + return objects.join(' '); + } + + var i = 1; + var args = arguments; + var len = args.length; + var str = String(f).replace(formatRegExp, function(x) { + if (x === '%%') return '%'; + if (i >= len) return x; + switch (x) { + case '%s': return String(args[i++]); + case '%d': return Number(args[i++]); + case '%j': + try { + return JSON.stringify(args[i++]); + } catch (_) { + return '[Circular]'; + } + default: + return x; + } + }); + for (var x = args[i]; i < len; x = args[++i]) { + if (isNull(x) || !isObject(x)) { + str += ' ' + x; + } else { + str += ' ' + inspect(x); + } + } + return str; +}; + + +// Mark that a method should not be used. +// Returns a modified function which warns once by default. +// If --no-deprecation is set, then it is a no-op. +exports.deprecate = function(fn, msg) { + if (typeof process !== 'undefined' && process.noDeprecation === true) { + return fn; + } + + // Allow for deprecating things in the process of starting up. + if (typeof process === 'undefined') { + return function() { + return exports.deprecate(fn, msg).apply(this, arguments); + }; + } + + var warned = false; + function deprecated() { + if (!warned) { + if (process.throwDeprecation) { + throw new Error(msg); + } else if (process.traceDeprecation) { + console.trace(msg); + } else { + console.error(msg); + } + warned = true; + } + return fn.apply(this, arguments); + } + + return deprecated; +}; + + +var debugs = {}; +var debugEnvRegex = /^$/; + +if (process.env.NODE_DEBUG) { + var debugEnv = process.env.NODE_DEBUG; + debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, '\\$&') + .replace(/\*/g, '.*') + .replace(/,/g, '$|^') + .toUpperCase(); + debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i'); +} +exports.debuglog = function(set) { + set = set.toUpperCase(); + if (!debugs[set]) { + if (debugEnvRegex.test(set)) { + var pid = process.pid; + debugs[set] = function() { + var msg = exports.format.apply(exports, arguments); + console.error('%s %d: %s', set, pid, msg); + }; + } else { + debugs[set] = function() {}; + } + } + return debugs[set]; +}; + + +/** + * Echos the value of a value. Trys to print the value out + * in the best way possible given the different types. + * + * @param {Object} obj The object to print out. + * @param {Object} opts Optional options object that alters the output. + */ +/* legacy: obj, showHidden, depth, colors*/ +function inspect(obj, opts) { + // default options + var ctx = { + seen: [], + stylize: stylizeNoColor + }; + // legacy... + if (arguments.length >= 3) ctx.depth = arguments[2]; + if (arguments.length >= 4) ctx.colors = arguments[3]; + if (isBoolean(opts)) { + // legacy... + ctx.showHidden = opts; + } else if (opts) { + // got an "options" object + exports._extend(ctx, opts); + } + // set default options + if (isUndefined(ctx.showHidden)) ctx.showHidden = false; + if (isUndefined(ctx.depth)) ctx.depth = 2; + if (isUndefined(ctx.colors)) ctx.colors = false; + if (isUndefined(ctx.customInspect)) ctx.customInspect = true; + if (ctx.colors) ctx.stylize = stylizeWithColor; + return formatValue(ctx, obj, ctx.depth); +} +exports.inspect = inspect; + + +// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics +inspect.colors = { + 'bold' : [1, 22], + 'italic' : [3, 23], + 'underline' : [4, 24], + 'inverse' : [7, 27], + 'white' : [37, 39], + 'grey' : [90, 39], + 'black' : [30, 39], + 'blue' : [34, 39], + 'cyan' : [36, 39], + 'green' : [32, 39], + 'magenta' : [35, 39], + 'red' : [31, 39], + 'yellow' : [33, 39] +}; + +// Don't use 'blue' not visible on cmd.exe +inspect.styles = { + 'special': 'cyan', + 'number': 'yellow', + 'boolean': 'yellow', + 'undefined': 'grey', + 'null': 'bold', + 'string': 'green', + 'date': 'magenta', + // "name": intentionally not styling + 'regexp': 'red' +}; + + +function stylizeWithColor(str, styleType) { + var style = inspect.styles[styleType]; + + if (style) { + return '\u001b[' + inspect.colors[style][0] + 'm' + str + + '\u001b[' + inspect.colors[style][1] + 'm'; + } else { + return str; + } +} + + +function stylizeNoColor(str, styleType) { + return str; +} + + +function arrayToHash(array) { + var hash = {}; + + array.forEach(function(val, idx) { + hash[val] = true; + }); + + return hash; +} + + +function formatValue(ctx, value, recurseTimes) { + // Provide a hook for user-specified inspect functions. + // Check that value is an object with an inspect function on it + if (ctx.customInspect && + value && + isFunction(value.inspect) && + // Filter out the util module, it's inspect function is special + value.inspect !== exports.inspect && + // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes, ctx); + if (!isString(ret)) { + ret = formatValue(ctx, ret, recurseTimes); + } + return ret; + } + + // Primitive types cannot have properties + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } + + // Look up the keys of the object. + var keys = Object.keys(value); + var visibleKeys = arrayToHash(keys); + + if (ctx.showHidden) { + keys = Object.getOwnPropertyNames(value); + } + + // IE doesn't make error fields non-enumerable + // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx + if (isError(value) + && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) { + return formatError(value); + } + + // Some type of object without properties can be shortcutted. + if (keys.length === 0) { + if (isFunction(value)) { + var name = value.name ? ': ' + value.name : ''; + return ctx.stylize('[Function' + name + ']', 'special'); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toString.call(value), 'date'); + } + if (isError(value)) { + return formatError(value); + } + } + + var base = '', array = false, braces = ['{', '}']; + + // Make Array say that they are Array + if (isArray(value)) { + array = true; + braces = ['[', ']']; + } + + // Make functions say that they are functions + if (isFunction(value)) { + var n = value.name ? ': ' + value.name : ''; + base = ' [Function' + n + ']'; + } + + // Make RegExps say that they are RegExps + if (isRegExp(value)) { + base = ' ' + RegExp.prototype.toString.call(value); + } + + // Make dates with properties first say the date + if (isDate(value)) { + base = ' ' + Date.prototype.toUTCString.call(value); + } + + // Make error with message first say the error + if (isError(value)) { + base = ' ' + formatError(value); + } + + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base + braces[1]; + } + + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } else { + return ctx.stylize('[Object]', 'special'); + } + } + + ctx.seen.push(value); + + var output; + if (array) { + output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); + }); + } + + ctx.seen.pop(); + + return reduceToSingleString(output, base, braces); +} + + +function formatPrimitive(ctx, value) { + if (isUndefined(value)) + return ctx.stylize('undefined', 'undefined'); + if (isString(value)) { + var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') + .replace(/'/g, "\\'") + .replace(/\\"/g, '"') + '\''; + return ctx.stylize(simple, 'string'); + } + if (isNumber(value)) + return ctx.stylize('' + value, 'number'); + if (isBoolean(value)) + return ctx.stylize('' + value, 'boolean'); + // For some reason typeof null is "object", so special case here. + if (isNull(value)) + return ctx.stylize('null', 'null'); +} + + +function formatError(value) { + return '[' + Error.prototype.toString.call(value) + ']'; +} + + +function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i = 0, l = value.length; i < l; ++i) { + if (hasOwnProperty(value, String(i))) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + String(i), true)); + } else { + output.push(''); + } + } + keys.forEach(function(key) { + if (!key.match(/^\d+$/)) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + key, true)); + } + }); + return output; +} + + +function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { + var name, str, desc; + desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }; + if (desc.get) { + if (desc.set) { + str = ctx.stylize('[Getter/Setter]', 'special'); + } else { + str = ctx.stylize('[Getter]', 'special'); + } + } else { + if (desc.set) { + str = ctx.stylize('[Setter]', 'special'); + } + } + if (!hasOwnProperty(visibleKeys, key)) { + name = '[' + key + ']'; + } + if (!str) { + if (ctx.seen.indexOf(desc.value) < 0) { + if (isNull(recurseTimes)) { + str = formatValue(ctx, desc.value, null); + } else { + str = formatValue(ctx, desc.value, recurseTimes - 1); + } + if (str.indexOf('\n') > -1) { + if (array) { + str = str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n').slice(2); + } else { + str = '\n' + str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n'); + } + } + } else { + str = ctx.stylize('[Circular]', 'special'); + } + } + if (isUndefined(name)) { + if (array && key.match(/^\d+$/)) { + return str; + } + name = JSON.stringify('' + key); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.slice(1, -1); + name = ctx.stylize(name, 'name'); + } else { + name = name.replace(/'/g, "\\'") + .replace(/\\"/g, '"') + .replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, 'string'); + } + } + + return name + ': ' + str; +} + + +function reduceToSingleString(output, base, braces) { + var numLinesEst = 0; + var length = output.reduce(function(prev, cur) { + numLinesEst++; + if (cur.indexOf('\n') >= 0) numLinesEst++; + return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1; + }, 0); + + if (length > 60) { + return braces[0] + + (base === '' ? '' : base + '\n ') + + ' ' + + output.join(',\n ') + + ' ' + + braces[1]; + } + + return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; +} + + +// NOTE: These type checking functions intentionally don't use `instanceof` +// because it is fragile and can be easily faked with `Object.create()`. +exports.types = __webpack_require__(9490); + +function isArray(ar) { + return Array.isArray(ar); +} +exports.isArray = isArray; + +function isBoolean(arg) { + return typeof arg === 'boolean'; +} +exports.isBoolean = isBoolean; + +function isNull(arg) { + return arg === null; +} +exports.isNull = isNull; + +function isNullOrUndefined(arg) { + return arg == null; +} +exports.isNullOrUndefined = isNullOrUndefined; + +function isNumber(arg) { + return typeof arg === 'number'; +} +exports.isNumber = isNumber; + +function isString(arg) { + return typeof arg === 'string'; +} +exports.isString = isString; + +function isSymbol(arg) { + return typeof arg === 'symbol'; +} +exports.isSymbol = isSymbol; + +function isUndefined(arg) { + return arg === void 0; +} +exports.isUndefined = isUndefined; + +function isRegExp(re) { + return isObject(re) && objectToString(re) === '[object RegExp]'; +} +exports.isRegExp = isRegExp; +exports.types.isRegExp = isRegExp; + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} +exports.isObject = isObject; + +function isDate(d) { + return isObject(d) && objectToString(d) === '[object Date]'; +} +exports.isDate = isDate; +exports.types.isDate = isDate; + +function isError(e) { + return isObject(e) && + (objectToString(e) === '[object Error]' || e instanceof Error); +} +exports.isError = isError; +exports.types.isNativeError = isError; + +function isFunction(arg) { + return typeof arg === 'function'; +} +exports.isFunction = isFunction; + +function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; +} +exports.isPrimitive = isPrimitive; + +exports.isBuffer = __webpack_require__(1201); + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + + +function pad(n) { + return n < 10 ? '0' + n.toString(10) : n.toString(10); +} + + +var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', + 'Oct', 'Nov', 'Dec']; + +// 26 Feb 16:19:34 +function timestamp() { + var d = new Date(); + var time = [pad(d.getHours()), + pad(d.getMinutes()), + pad(d.getSeconds())].join(':'); + return [d.getDate(), months[d.getMonth()], time].join(' '); +} + + +// log is just a thin wrapper to console.log that prepends a timestamp +exports.log = function() { + console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments)); +}; + + +/** + * Inherit the prototype methods from one constructor into another. + * + * The Function.prototype.inherits from lang.js rewritten as a standalone + * function (not on Function.prototype). NOTE: If this file is to be loaded + * during bootstrapping this function needs to be rewritten using some native + * functions as prototype setup using normal JavaScript does not work as + * expected during bootstrapping (see mirror.js in r114903). + * + * @param {function} ctor Constructor function which needs to inherit the + * prototype. + * @param {function} superCtor Constructor function to inherit prototype from. + */ +exports.inherits = __webpack_require__(9784); + +exports._extend = function(origin, add) { + // Don't do anything if add isn't an object + if (!add || !isObject(add)) return origin; + + var keys = Object.keys(add); + var i = keys.length; + while (i--) { + origin[keys[i]] = add[keys[i]]; + } + return origin; +}; + +function hasOwnProperty(obj, prop) { + return Object.prototype.hasOwnProperty.call(obj, prop); +} + +var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined; + +exports.promisify = function promisify(original) { + if (typeof original !== 'function') + throw new TypeError('The "original" argument must be of type Function'); + + if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) { + var fn = original[kCustomPromisifiedSymbol]; + if (typeof fn !== 'function') { + throw new TypeError('The "util.promisify.custom" argument must be of type Function'); + } + Object.defineProperty(fn, kCustomPromisifiedSymbol, { + value: fn, enumerable: false, writable: false, configurable: true + }); + return fn; + } + + function fn() { + var promiseResolve, promiseReject; + var promise = new Promise(function (resolve, reject) { + promiseResolve = resolve; + promiseReject = reject; + }); + + var args = []; + for (var i = 0; i < arguments.length; i++) { + args.push(arguments[i]); + } + args.push(function (err, value) { + if (err) { + promiseReject(err); + } else { + promiseResolve(value); + } + }); + + try { + original.apply(this, args); + } catch (err) { + promiseReject(err); + } + + return promise; + } + + Object.setPrototypeOf(fn, Object.getPrototypeOf(original)); + + if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, { + value: fn, enumerable: false, writable: false, configurable: true + }); + return Object.defineProperties( + fn, + getOwnPropertyDescriptors(original) + ); +} + +exports.promisify.custom = kCustomPromisifiedSymbol + +function callbackifyOnRejected(reason, cb) { + // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M). + // Because `null` is a special error value in callbacks which means "no error + // occurred", we error-wrap so the callback consumer can distinguish between + // "the promise rejected with null" or "the promise fulfilled with undefined". + if (!reason) { + var newReason = new Error('Promise was rejected with a falsy value'); + newReason.reason = reason; + reason = newReason; + } + return cb(reason); +} + +function callbackify(original) { + if (typeof original !== 'function') { + throw new TypeError('The "original" argument must be of type Function'); + } + + // We DO NOT return the promise as it gives the user a false sense that + // the promise is actually somehow related to the callback's execution + // and that the callback throwing will reject the promise. + function callbackified() { + var args = []; + for (var i = 0; i < arguments.length; i++) { + args.push(arguments[i]); + } + + var maybeCb = args.pop(); + if (typeof maybeCb !== 'function') { + throw new TypeError('The last argument must be of type Function'); + } + var self = this; + var cb = function() { + return maybeCb.apply(self, arguments); + }; + // In true node style we process the callback on `nextTick` with all the + // implications (stack, `uncaughtException`, `async_hooks`) + original.apply(this, args) + .then(function(ret) { process.nextTick(cb.bind(null, null, ret)) }, + function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) }); + } + + Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original)); + Object.defineProperties(callbackified, + getOwnPropertyDescriptors(original)); + return callbackified; +} +exports.callbackify = callbackify; + + +/***/ }, + +/***/ 3381 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var forEach = __webpack_require__(8404); +var availableTypedArrays = __webpack_require__(821); +var callBind = __webpack_require__(6601); +var callBound = __webpack_require__(2774); +var gOPD = __webpack_require__(8109); +var getProto = __webpack_require__(7106); + +var $toString = callBound('Object.prototype.toString'); +var hasToStringTag = __webpack_require__(6626)(); + +var g = typeof globalThis === 'undefined' ? __webpack_require__.g : globalThis; +var typedArrays = availableTypedArrays(); + +var $slice = callBound('String.prototype.slice'); + +/** @type {(array: readonly T[], value: unknown) => number} */ +var $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) { + for (var i = 0; i < array.length; i += 1) { + if (array[i] === value) { + return i; + } + } + return -1; +}; + +/** @typedef {import('./types').Getter} Getter */ +/** @type {import('./types').Cache} */ +var cache = { __proto__: null }; +if (hasToStringTag && gOPD && getProto) { + forEach(typedArrays, function (typedArray) { + var arr = new g[typedArray](); + if (Symbol.toStringTag in arr && getProto) { + var proto = getProto(arr); + // @ts-expect-error TS won't narrow inside a closure + var descriptor = gOPD(proto, Symbol.toStringTag); + if (!descriptor && proto) { + var superProto = getProto(proto); + // @ts-expect-error TS won't narrow inside a closure + descriptor = gOPD(superProto, Symbol.toStringTag); + } + if (descriptor && descriptor.get) { + var bound = callBind(descriptor.get); + cache[ + /** @type {`$${import('.').TypedArrayName}`} */ ('$' + typedArray) + ] = bound; + } + } + }); +} else { + forEach(typedArrays, function (typedArray) { + var arr = new g[typedArray](); + var fn = arr.slice || arr.set; + if (fn) { + var bound = /** @type {import('./types').BoundSlice | import('./types').BoundSet} */ ( + // @ts-expect-error TODO FIXME + callBind(fn) + ); + cache[ + /** @type {`$${import('.').TypedArrayName}`} */ ('$' + typedArray) + ] = bound; + } + }); +} + +/** @type {(value: object) => false | import('.').TypedArrayName} */ +var tryTypedArrays = function tryAllTypedArrays(value) { + /** @type {ReturnType} */ var found = false; + forEach( + /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */ (cache), + /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */ + function (getter, typedArray) { + if (!found) { + try { + // @ts-expect-error a throw is fine here + if ('$' + getter(value) === typedArray) { + found = /** @type {import('.').TypedArrayName} */ ($slice(typedArray, 1)); + } + } catch (e) { /**/ } + } + } + ); + return found; +}; + +/** @type {(value: object) => false | import('.').TypedArrayName} */ +var trySlices = function tryAllSlices(value) { + /** @type {ReturnType} */ var found = false; + forEach( + /** @type {Record<`\$${import('.').TypedArrayName}`, Getter>} */(cache), + /** @type {(getter: Getter, name: `\$${import('.').TypedArrayName}`) => void} */ function (getter, name) { + if (!found) { + try { + // @ts-expect-error a throw is fine here + getter(value); + found = /** @type {import('.').TypedArrayName} */ ($slice(name, 1)); + } catch (e) { /**/ } + } + } + ); + return found; +}; + +/** @type {import('.')} */ +module.exports = function whichTypedArray(value) { + if (!value || typeof value !== 'object') { return false; } + if (!hasToStringTag) { + /** @type {string} */ + var tag = $slice($toString(value), 8, -1); + if ($indexOf(typedArrays, tag) > -1) { + return tag; + } + if (tag !== 'Object') { + return false; + } + // node < 0.6 hits here on real Typed Arrays + return trySlices(value); + } + if (!gOPD) { return null; } // unknown engine + return tryTypedArrays(value); +}; + + +/***/ }, + +/***/ 8679 +(module, exports, __webpack_require__) { + +var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function(a,b){if(true)!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (b), + __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? + (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), + __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));else // removed by dead control flow +{}})(this,function(){"use strict";function b(a,b){return"undefined"==typeof b?b={autoBom:!1}:"object"!=typeof b&&(console.warn("Deprecated: Expected third argument to be a object"),b={autoBom:!b}),b.autoBom&&/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(a.type)?new Blob(["\uFEFF",a],{type:a.type}):a}function c(a,b,c){var d=new XMLHttpRequest;d.open("GET",a),d.responseType="blob",d.onload=function(){g(d.response,b,c)},d.onerror=function(){console.error("could not download file")},d.send()}function d(a){var b=new XMLHttpRequest;b.open("HEAD",a,!1);try{b.send()}catch(a){}return 200<=b.status&&299>=b.status}function e(a){try{a.dispatchEvent(new MouseEvent("click"))}catch(c){var b=document.createEvent("MouseEvents");b.initMouseEvent("click",!0,!0,window,0,0,0,80,20,!1,!1,!1,!1,0,null),a.dispatchEvent(b)}}var f="object"==typeof window&&window.window===window?window:"object"==typeof self&&self.self===self?self:"object"==typeof __webpack_require__.g&&__webpack_require__.g.global===__webpack_require__.g?__webpack_require__.g:void 0,a=f.navigator&&/Macintosh/.test(navigator.userAgent)&&/AppleWebKit/.test(navigator.userAgent)&&!/Safari/.test(navigator.userAgent),g=f.saveAs||("object"!=typeof window||window!==f?function(){}:(typeof HTMLAnchorElement !== "undefined" && "download" in HTMLAnchorElement.prototype)&&!a?function(b,g,h){var i=f.URL||f.webkitURL,j=document.createElement("a");g=g||b.name||"download",j.download=g,j.rel="noopener","string"==typeof b?(j.href=b,j.origin===location.origin?e(j):d(j.href)?c(b,g,h):e(j,j.target="_blank")):(j.href=i.createObjectURL(b),setTimeout(function(){i.revokeObjectURL(j.href)},4E4),setTimeout(function(){e(j)},0))}:"msSaveOrOpenBlob"in navigator?function(f,g,h){if(g=g||f.name||"download","string"!=typeof f)navigator.msSaveOrOpenBlob(b(f,h),g);else if(d(f))c(f,g,h);else{var i=document.createElement("a");i.href=f,i.target="_blank",setTimeout(function(){e(i)})}}:function(b,d,e,g){if(g=g||open("","_blank"),g&&(g.document.title=g.document.body.innerText="downloading..."),"string"==typeof b)return c(b,d,e);var h="application/octet-stream"===b.type,i=/constructor/i.test(f.HTMLElement)||f.safari,j=/CriOS\/[\d]+/.test(navigator.userAgent);if((j||h&&i||a)&&"undefined"!=typeof FileReader){var k=new FileReader;k.onloadend=function(){var a=k.result;a=j?a:a.replace(/^data:[^;]*;/,"data:attachment/file;"),g?g.location.href=a:location=a,g=null},k.readAsDataURL(b)}else{var l=f.URL||f.webkitURL,m=l.createObjectURL(b);g?g.location=m:location.href=m,g=null,setTimeout(function(){l.revokeObjectURL(m)},4E4)}});f.saveAs=g.saveAs=g, true&&(module.exports=g)}); + + + +/***/ }, + +/***/ 6274 +() { + +/* (ignored) */ + +/***/ }, + +/***/ 8535 +() { + +/* (ignored) */ + +/***/ }, + +/***/ 5470 +() { + +/* (ignored) */ + +/***/ }, + +/***/ 3779 +() { + +/* (ignored) */ + +/***/ }, + +/***/ 7199 +() { + +/* (ignored) */ + +/***/ }, + +/***/ 5117 +(module) { + +"use strict"; + + +// eslint-disable-next-line es/no-typed-arrays -- safe +module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined'; + +/***/ }, + +/***/ 4074 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var NATIVE_ARRAY_BUFFER = __webpack_require__(5117); +var DESCRIPTORS = __webpack_require__(5144); +var globalThis = __webpack_require__(7756); +var isCallable = __webpack_require__(8681); +var isObject = __webpack_require__(3598); +var hasOwn = __webpack_require__(6341); +var classof = __webpack_require__(9391); +var tryToString = __webpack_require__(8819); +var createNonEnumerableProperty = __webpack_require__(5719); +var defineBuiltIn = __webpack_require__(4092); +var defineBuiltInAccessor = __webpack_require__(1182); +var isPrototypeOf = __webpack_require__(9877); +var getPrototypeOf = __webpack_require__(8607); +var setPrototypeOf = __webpack_require__(443); +var wellKnownSymbol = __webpack_require__(8663); +var uid = __webpack_require__(6044); +var InternalStateModule = __webpack_require__(6921); +var enforceInternalState = InternalStateModule.enforce; +var getInternalState = InternalStateModule.get; +var Int8Array = globalThis.Int8Array; +var Int8ArrayPrototype = Int8Array && Int8Array.prototype; +var Uint8ClampedArray = globalThis.Uint8ClampedArray; +var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype; +var TypedArray = Int8Array && getPrototypeOf(Int8Array); +var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype); +var ObjectPrototype = Object.prototype; +var TypeError = globalThis.TypeError; +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG'); +var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor'; +// Fixing native typed arrays in Opera Presto crashes the browser, see #595 +var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(globalThis.opera) !== 'Opera'; +var TYPED_ARRAY_TAG_REQUIRED = false; +var NAME, Constructor, Prototype; +var TypedArrayConstructorsList = { + Int8Array: 1, + Uint8Array: 1, + Uint8ClampedArray: 1, + Int16Array: 2, + Uint16Array: 2, + Int32Array: 4, + Uint32Array: 4, + Float32Array: 4, + Float64Array: 8 +}; +var BigIntArrayConstructorsList = { + BigInt64Array: 8, + BigUint64Array: 8 +}; +var isView = function isView(it) { + if (!isObject(it)) return false; + var klass = classof(it); + return klass === 'DataView' || hasOwn(TypedArrayConstructorsList, klass) || hasOwn(BigIntArrayConstructorsList, klass); +}; +var getTypedArrayConstructor = function (it) { + var proto = getPrototypeOf(it); + if (!isObject(proto)) return; + var state = getInternalState(proto); + return state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto); +}; +var isTypedArray = function (it) { + if (!isObject(it)) return false; + var klass = classof(it); + return hasOwn(TypedArrayConstructorsList, klass) || hasOwn(BigIntArrayConstructorsList, klass); +}; +var aTypedArray = function (it) { + if (isTypedArray(it)) return it; + throw new TypeError('Target is not a typed array'); +}; +var aTypedArrayConstructor = function (C) { + if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C; + throw new TypeError(tryToString(C) + ' is not a typed array constructor'); +}; +var exportTypedArrayMethod = function (KEY, property, forced, options) { + if (!DESCRIPTORS) return; + if (forced) for (var ARRAY in TypedArrayConstructorsList) { + var TypedArrayConstructor = globalThis[ARRAY]; + if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try { + delete TypedArrayConstructor.prototype[KEY]; + } catch (error) { + // old WebKit bug - some methods are non-configurable + try { + TypedArrayConstructor.prototype[KEY] = property; + } catch (error2) {/* empty */} + } + } + if (!TypedArrayPrototype[KEY] || forced) { + defineBuiltIn(TypedArrayPrototype, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options); + } +}; +var exportTypedArrayStaticMethod = function (KEY, property, forced) { + var ARRAY, TypedArrayConstructor; + if (!DESCRIPTORS) return; + if (setPrototypeOf) { + if (forced) for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = globalThis[ARRAY]; + if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try { + delete TypedArrayConstructor[KEY]; + } catch (error) {/* empty */} + } + if (!TypedArray[KEY] || forced) { + // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable + try { + return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property); + } catch (error) {/* empty */} + } else return; + } + for (ARRAY in TypedArrayConstructorsList) { + TypedArrayConstructor = globalThis[ARRAY]; + if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) { + defineBuiltIn(TypedArrayConstructor, KEY, property); + } + } +}; +for (NAME in TypedArrayConstructorsList) { + Constructor = globalThis[NAME]; + Prototype = Constructor && Constructor.prototype; + if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;else NATIVE_ARRAY_BUFFER_VIEWS = false; +} +for (NAME in BigIntArrayConstructorsList) { + Constructor = globalThis[NAME]; + Prototype = Constructor && Constructor.prototype; + if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor; +} + +// WebKit bug - typed arrays constructors prototype is Object.prototype +if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) { + // eslint-disable-next-line no-shadow -- safe + TypedArray = function TypedArray() { + throw new TypeError('Incorrect invocation'); + }; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { + if (globalThis[NAME]) setPrototypeOf(globalThis[NAME], TypedArray); + } +} +if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) { + TypedArrayPrototype = TypedArray.prototype; + if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) { + if (globalThis[NAME]) setPrototypeOf(globalThis[NAME].prototype, TypedArrayPrototype); + } +} + +// WebKit bug - one more object in Uint8ClampedArray prototype chain +if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) { + setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype); +} +if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) { + TYPED_ARRAY_TAG_REQUIRED = true; + defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, { + configurable: true, + get: function () { + return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined; + } + }); + for (NAME in TypedArrayConstructorsList) if (globalThis[NAME]) { + createNonEnumerableProperty(globalThis[NAME].prototype, TYPED_ARRAY_TAG, NAME); + } +} +module.exports = { + NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS, + TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG, + aTypedArray: aTypedArray, + aTypedArrayConstructor: aTypedArrayConstructor, + exportTypedArrayMethod: exportTypedArrayMethod, + exportTypedArrayStaticMethod: exportTypedArrayStaticMethod, + getTypedArrayConstructor: getTypedArrayConstructor, + isView: isView, + isTypedArray: isTypedArray, + TypedArray: TypedArray, + TypedArrayPrototype: TypedArrayPrototype +}; + +/***/ }, + +/***/ 4415 +(__unused_webpack_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; + + +/***/ }, + +/***/ 8395 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + + +exports._ = __webpack_require__(1635).__decorate; + + +/***/ }, + +/***/ 821 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +var possibleNames = __webpack_require__(884); + +var g = typeof globalThis === 'undefined' ? __webpack_require__.g : globalThis; + +/** @type {import('.')} */ +module.exports = function availableTypedArrays() { + var /** @type {ReturnType} */ out = []; + for (var i = 0; i < possibleNames.length; i++) { + if (typeof g[possibleNames[i]] === 'function') { + // @ts-expect-error + out[out.length] = possibleNames[i]; + } + } + return out; +}; + + +/***/ }, + +/***/ 890 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var hasOwn = __webpack_require__(6341); +var isArray = __webpack_require__(8468); +var isForced = __webpack_require__(5888); +var shared = __webpack_require__(3793); + +var data = isForced.data; +var normalize = isForced.normalize; +var USE_FUNCTION_CONSTRUCTOR = 'USE_FUNCTION_CONSTRUCTOR'; +var ASYNC_ITERATOR_PROTOTYPE = 'AsyncIteratorPrototype'; + +var setAggressivenessLevel = function (object, constant) { + if (isArray(object)) for (var i = 0; i < object.length; i++) data[normalize(object[i])] = constant; +}; + +module.exports = function (options) { + if (options && typeof options == 'object') { + setAggressivenessLevel(options.useNative, isForced.NATIVE); + setAggressivenessLevel(options.usePolyfill, isForced.POLYFILL); + setAggressivenessLevel(options.useFeatureDetection, null); + if (hasOwn(options, USE_FUNCTION_CONSTRUCTOR)) { + shared[USE_FUNCTION_CONSTRUCTOR] = !!options[USE_FUNCTION_CONSTRUCTOR]; + } + if (hasOwn(options, ASYNC_ITERATOR_PROTOTYPE)) { + shared[ASYNC_ITERATOR_PROTOTYPE] = options[ASYNC_ITERATOR_PROTOTYPE]; + } + } +}; + + +/***/ }, + +/***/ 1078 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(8681); +var tryToString = __webpack_require__(8819); + +var $TypeError = TypeError; + +// `Assert: IsCallable(argument) is true` +module.exports = function (argument) { + if (isCallable(argument)) return argument; + throw new $TypeError(tryToString(argument) + ' is not a function'); +}; + + +/***/ }, + +/***/ 7222 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var isPossiblePrototype = __webpack_require__(2657); + +var $String = String; +var $TypeError = TypeError; + +module.exports = function (argument) { + if (isPossiblePrototype(argument)) return argument; + throw new $TypeError("Can't set " + $String(argument) + ' as a prototype'); +}; + + +/***/ }, + +/***/ 1825 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(8663); +var create = __webpack_require__(4860); +var defineProperty = (__webpack_require__(2333).f); + +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +module.exports = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + + +/***/ }, + +/***/ 2091 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(3598); + +var $String = String; +var $TypeError = TypeError; + +// `Assert: Type(argument) is Object` +module.exports = function (argument) { + if (isObject(argument)) return argument; + throw new $TypeError($String(argument) + ' is not an object'); +}; + + +/***/ }, + +/***/ 3161 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toObject = __webpack_require__(3297); +var toAbsoluteIndex = __webpack_require__(4918); +var lengthOfArrayLike = __webpack_require__(4730); + +// `Array.prototype.fill` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.fill +module.exports = function fill(value /* , start = 0, end = @length */) { + var O = toObject(this); + var length = lengthOfArrayLike(O); + var argumentsLength = arguments.length; + var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length); + var end = argumentsLength > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex(end, length); + while (endPos > index) O[index++] = value; + return O; +}; + + +/***/ }, + +/***/ 789 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toIndexedObject = __webpack_require__(5137); +var toAbsoluteIndex = __webpack_require__(4918); +var lengthOfArrayLike = __webpack_require__(4730); + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = lengthOfArrayLike(O); + if (length === 0) return !IS_INCLUDES && -1; + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +module.exports = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) +}; + + +/***/ }, + +/***/ 2740 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); + +module.exports = uncurryThis([].slice); + + +/***/ }, + +/***/ 644 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var arraySlice = __webpack_require__(2740); + +var floor = Math.floor; + +var sort = function (array, comparefn) { + var length = array.length; + + if (length < 8) { + // insertion sort + var i = 1; + var element, j; + + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) array[j] = element; + } + } else { + // merge sort + var middle = floor(length / 2); + var left = sort(arraySlice(array, 0, middle), comparefn); + var right = sort(arraySlice(array, middle), comparefn); + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = (lindex < llength && rindex < rlength) + ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] + : lindex < llength ? left[lindex++] : right[rindex++]; + } + } + + return array; +}; + +module.exports = sort; + + +/***/ }, + +/***/ 8420 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); + +var toString = uncurryThis({}.toString); +var stringSlice = uncurryThis(''.slice); + +module.exports = function (it) { + return stringSlice(toString(it), 8, -1); +}; + + +/***/ }, + +/***/ 9391 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__(7920); +var isCallable = __webpack_require__(8681); +var classofRaw = __webpack_require__(8420); +var wellKnownSymbol = __webpack_require__(8663); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var $Object = Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw(O) + // ES3 arguments fallback + : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result; +}; + + +/***/ }, + +/***/ 8032 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var hasOwn = __webpack_require__(6341); +var ownKeys = __webpack_require__(7523); +var getOwnPropertyDescriptorModule = __webpack_require__(423); +var definePropertyModule = __webpack_require__(2333); + +module.exports = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + + +/***/ }, + +/***/ 5071 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(299); + +module.exports = !fails(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + + +/***/ }, + +/***/ 5719 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(5144); +var definePropertyModule = __webpack_require__(2333); +var createPropertyDescriptor = __webpack_require__(8264); + +module.exports = DESCRIPTORS ? function (object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + + +/***/ }, + +/***/ 8264 +(module) { + +"use strict"; + +module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + + +/***/ }, + +/***/ 1182 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var makeBuiltIn = __webpack_require__(3383); +var defineProperty = __webpack_require__(2333); + +module.exports = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true }); + return defineProperty.f(target, name, descriptor); +}; + + +/***/ }, + +/***/ 4092 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(8681); +var definePropertyModule = __webpack_require__(2333); +var makeBuiltIn = __webpack_require__(3383); +var defineGlobalProperty = __webpack_require__(7309); + +module.exports = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; +}; + + +/***/ }, + +/***/ 7309 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty = Object.defineProperty; + +module.exports = function (key, value) { + try { + defineProperty(globalThis, key, { value: value, configurable: true, writable: true }); + } catch (error) { + globalThis[key] = value; + } return value; +}; + + +/***/ }, + +/***/ 5144 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(299); + +// Detect IE8's incomplete defineProperty implementation +module.exports = !fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; +}); + + +/***/ }, + +/***/ 2283 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var isObject = __webpack_require__(3598); + +var document = globalThis.document; +// typeof document.createElement is 'object' in old IE +var EXISTS = isObject(document) && isObject(document.createElement); + +module.exports = function (it) { + return EXISTS ? document.createElement(it) : {}; +}; + + +/***/ }, + +/***/ 2555 +(module) { + +"use strict"; + +// IE8- don't enum bug keys +module.exports = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + + +/***/ }, + +/***/ 5337 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var userAgent = __webpack_require__(8115); + +var firefox = userAgent.match(/firefox\/(\d+)/i); + +module.exports = !!firefox && +firefox[1]; + + +/***/ }, + +/***/ 7383 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var UA = __webpack_require__(8115); + +module.exports = /MSIE|Trident/.test(UA); + + +/***/ }, + +/***/ 8115 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); + +var navigator = globalThis.navigator; +var userAgent = navigator && navigator.userAgent; + +module.exports = userAgent ? String(userAgent) : ''; + + +/***/ }, + +/***/ 2227 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var userAgent = __webpack_require__(8115); + +var process = globalThis.process; +var Deno = globalThis.Deno; +var versions = process && process.versions || Deno && Deno.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +module.exports = version; + + +/***/ }, + +/***/ 4507 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var userAgent = __webpack_require__(8115); + +var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + +module.exports = !!webkit && +webkit[1]; + + +/***/ }, + +/***/ 3762 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var getOwnPropertyDescriptor = (__webpack_require__(423).f); +var createNonEnumerableProperty = __webpack_require__(5719); +var defineBuiltIn = __webpack_require__(4092); +var defineGlobalProperty = __webpack_require__(7309); +var copyConstructorProperties = __webpack_require__(8032); +var isForced = __webpack_require__(5888); + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +module.exports = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = globalThis; + } else if (STATIC) { + target = globalThis[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = globalThis[TARGET] && globalThis[TARGET].prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + defineBuiltIn(target, key, sourceProperty, options); + } +}; + + +/***/ }, + +/***/ 299 +(module) { + +"use strict"; + +module.exports = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + + +/***/ }, + +/***/ 1676 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(299); + +module.exports = !fails(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = function () { /* empty */ }.bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); +}); + + +/***/ }, + +/***/ 8993 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var NATIVE_BIND = __webpack_require__(1676); + +var call = Function.prototype.call; +// eslint-disable-next-line es/no-function-prototype-bind -- safe +module.exports = NATIVE_BIND ? call.bind(call) : function () { + return call.apply(call, arguments); +}; + + +/***/ }, + +/***/ 4378 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(5144); +var hasOwn = __webpack_require__(6341); + +var FunctionPrototype = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor; + +var EXISTS = hasOwn(FunctionPrototype, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS && function something() { /* empty */ }.name === 'something'; +var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable)); + +module.exports = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE +}; + + +/***/ }, + +/***/ 4494 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); +var aCallable = __webpack_require__(1078); + +module.exports = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } +}; + + +/***/ }, + +/***/ 5336 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var classofRaw = __webpack_require__(8420); +var uncurryThis = __webpack_require__(1212); + +module.exports = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis(fn); +}; + + +/***/ }, + +/***/ 1212 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var NATIVE_BIND = __webpack_require__(1676); + +var FunctionPrototype = Function.prototype; +var call = FunctionPrototype.call; +// eslint-disable-next-line es/no-function-prototype-bind -- safe +var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call); + +module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) { + return function () { + return call.apply(fn, arguments); + }; +}; + + +/***/ }, + +/***/ 7139 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var isCallable = __webpack_require__(8681); + +var aFunction = function (argument) { + return isCallable(argument) ? argument : undefined; +}; + +module.exports = function (namespace, method) { + return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method]; +}; + + +/***/ }, + +/***/ 9738 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var aCallable = __webpack_require__(1078); +var isNullOrUndefined = __webpack_require__(6297); + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +module.exports = function (V, P) { + var func = V[P]; + return isNullOrUndefined(func) ? undefined : aCallable(func); +}; + + +/***/ }, + +/***/ 7756 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var check = function (it) { + return it && it.Math === Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +module.exports = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof __webpack_require__.g == 'object' && __webpack_require__.g) || + check(typeof this == 'object' && this) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + +/***/ }, + +/***/ 6341 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); +var toObject = __webpack_require__(3297); + +var hasOwnProperty = uncurryThis({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +// eslint-disable-next-line es/no-object-hasown -- safe +module.exports = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject(it), key); +}; + + +/***/ }, + +/***/ 2993 +(module) { + +"use strict"; + +module.exports = {}; + + +/***/ }, + +/***/ 4329 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(7139); + +module.exports = getBuiltIn('document', 'documentElement'); + + +/***/ }, + +/***/ 7657 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(5144); +var fails = __webpack_require__(299); +var createElement = __webpack_require__(2283); + +// Thanks to IE8 for its funny defineProperty +module.exports = !DESCRIPTORS && !fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement('div'), 'a', { + get: function () { return 7; } + }).a !== 7; +}); + + +/***/ }, + +/***/ 2203 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); +var fails = __webpack_require__(299); +var classof = __webpack_require__(8420); + +var $Object = Object; +var split = uncurryThis(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +module.exports = fails(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof(it) === 'String' ? split(it, '') : $Object(it); +} : $Object; + + +/***/ }, + +/***/ 4550 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); +var isCallable = __webpack_require__(8681); +var store = __webpack_require__(3793); + +var functionToString = uncurryThis(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable(store.inspectSource)) { + store.inspectSource = function (it) { + return functionToString(it); + }; +} + +module.exports = store.inspectSource; + + +/***/ }, + +/***/ 6921 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var NATIVE_WEAK_MAP = __webpack_require__(1194); +var globalThis = __webpack_require__(7756); +var isObject = __webpack_require__(3598); +var createNonEnumerableProperty = __webpack_require__(5719); +var hasOwn = __webpack_require__(6341); +var shared = __webpack_require__(3793); +var sharedKey = __webpack_require__(7099); +var hiddenKeys = __webpack_require__(2993); + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError = globalThis.TypeError; +var WeakMap = globalThis.WeakMap; +var set, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw new TypeError('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set = function (it, metadata) { + if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; +} else { + var STATE = sharedKey('state'); + hiddenKeys[STATE] = true; + set = function (it, metadata) { + if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn(it, STATE); + }; +} + +module.exports = { + set: set, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + + +/***/ }, + +/***/ 8468 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var classof = __webpack_require__(8420); + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +// eslint-disable-next-line es/no-array-isarray -- safe +module.exports = Array.isArray || function isArray(argument) { + return classof(argument) === 'Array'; +}; + + +/***/ }, + +/***/ 8681 +(module) { + +"use strict"; + +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot +var documentAll = typeof document == 'object' && document.all; + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing +module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) { + return typeof argument == 'function' || argument === documentAll; +} : function (argument) { + return typeof argument == 'function'; +}; + + +/***/ }, + +/***/ 5888 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var fails = __webpack_require__(299); +var isCallable = __webpack_require__(8681); + +var replacement = /#|\.prototype\./; + +var isForced = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable(detection) ? fails(detection) + : !!detection; +}; + +var normalize = isForced.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced.data = {}; +var NATIVE = isForced.NATIVE = 'N'; +var POLYFILL = isForced.POLYFILL = 'P'; + +module.exports = isForced; + + +/***/ }, + +/***/ 6297 +(module) { + +"use strict"; + +// we can't use just `it == null` since of `document.all` special case +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec +module.exports = function (it) { + return it === null || it === undefined; +}; + + +/***/ }, + +/***/ 3598 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var isCallable = __webpack_require__(8681); + +module.exports = function (it) { + return typeof it == 'object' ? it !== null : isCallable(it); +}; + + +/***/ }, + +/***/ 2657 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var isObject = __webpack_require__(3598); + +module.exports = function (argument) { + return isObject(argument) || argument === null; +}; + + +/***/ }, + +/***/ 7695 +(module) { + +"use strict"; + +module.exports = false; + + +/***/ }, + +/***/ 5985 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(7139); +var isCallable = __webpack_require__(8681); +var isPrototypeOf = __webpack_require__(9877); +var USE_SYMBOL_AS_UID = __webpack_require__(8300); + +var $Object = Object; + +module.exports = USE_SYMBOL_AS_UID ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn('Symbol'); + return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it)); +}; + + +/***/ }, + +/***/ 4730 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toLength = __webpack_require__(8266); + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +module.exports = function (obj) { + return toLength(obj.length); +}; + + +/***/ }, + +/***/ 3383 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); +var fails = __webpack_require__(299); +var isCallable = __webpack_require__(8681); +var hasOwn = __webpack_require__(6341); +var DESCRIPTORS = __webpack_require__(5144); +var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(4378).CONFIGURABLE); +var inspectSource = __webpack_require__(4550); +var InternalStateModule = __webpack_require__(6921); + +var enforceInternalState = InternalStateModule.enforce; +var getInternalState = InternalStateModule.get; +var $String = String; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty = Object.defineProperty; +var stringSlice = uncurryThis(''.slice); +var replace = uncurryThis(''.replace); +var join = uncurryThis([].join); + +var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () { + return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; +}); + +var TEMPLATE = String(String).split('String'); + +var makeBuiltIn = module.exports = function (value, name, options) { + if (stringSlice($String(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) { + if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) { + defineProperty(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn(options, 'constructor') && options.constructor) { + if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; +}; + +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +// eslint-disable-next-line no-extend-native -- required +Function.prototype.toString = makeBuiltIn(function toString() { + return isCallable(this) && getInternalState(this).source || inspectSource(this); +}, 'toString'); + + +/***/ }, + +/***/ 2537 +(module) { + +"use strict"; + +var ceil = Math.ceil; +var floor = Math.floor; + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +// eslint-disable-next-line es/no-math-trunc -- safe +module.exports = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); +}; + + +/***/ }, + +/***/ 4860 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +/* global ActiveXObject -- old IE, WSH */ +var anObject = __webpack_require__(2091); +var definePropertiesModule = __webpack_require__(2197); +var enumBugKeys = __webpack_require__(2555); +var hiddenKeys = __webpack_require__(2993); +var html = __webpack_require__(4329); +var documentCreateElement = __webpack_require__(2283); +var sharedKey = __webpack_require__(7099); + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO = sharedKey('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + // eslint-disable-next-line no-useless-assignment -- avoid memory leak + activeXDocument = null; + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys[IE_PROTO] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +// eslint-disable-next-line es/no-object-create -- safe +module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); +}; + + +/***/ }, + +/***/ 2197 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(5144); +var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(2538); +var definePropertyModule = __webpack_require__(2333); +var anObject = __webpack_require__(2091); +var toIndexedObject = __webpack_require__(5137); +var objectKeys = __webpack_require__(9428); + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var props = toIndexedObject(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]); + return O; +}; + + +/***/ }, + +/***/ 2333 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(5144); +var IE8_DOM_DEFINE = __webpack_require__(7657); +var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(2538); +var anObject = __webpack_require__(2091); +var toPropertyKey = __webpack_require__(1413); + +var $TypeError = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var ENUMERABLE = 'enumerable'; +var CONFIGURABLE = 'configurable'; +var WRITABLE = 'writable'; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); +} : $defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + + +/***/ }, + +/***/ 423 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(5144); +var call = __webpack_require__(8993); +var propertyIsEnumerableModule = __webpack_require__(4961); +var createPropertyDescriptor = __webpack_require__(8264); +var toIndexedObject = __webpack_require__(5137); +var toPropertyKey = __webpack_require__(1413); +var hasOwn = __webpack_require__(6341); +var IE8_DOM_DEFINE = __webpack_require__(7657); + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPropertyKey(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]); +}; + + +/***/ }, + +/***/ 5412 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var internalObjectKeys = __webpack_require__(3120); +var enumBugKeys = __webpack_require__(2555); + +var hiddenKeys = enumBugKeys.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); +}; + + +/***/ }, + +/***/ 4073 +(__unused_webpack_module, exports) { + +"use strict"; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +exports.f = Object.getOwnPropertySymbols; + + +/***/ }, + +/***/ 8607 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var hasOwn = __webpack_require__(6341); +var isCallable = __webpack_require__(8681); +var toObject = __webpack_require__(3297); +var sharedKey = __webpack_require__(7099); +var CORRECT_PROTOTYPE_GETTER = __webpack_require__(5071); + +var IE_PROTO = sharedKey('IE_PROTO'); +var $Object = Object; +var ObjectPrototype = $Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +// eslint-disable-next-line es/no-object-getprototypeof -- safe +module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject(O); + if (hasOwn(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; +}; + + +/***/ }, + +/***/ 9877 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); + +module.exports = uncurryThis({}.isPrototypeOf); + + +/***/ }, + +/***/ 3120 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); +var hasOwn = __webpack_require__(6341); +var toIndexedObject = __webpack_require__(5137); +var indexOf = (__webpack_require__(789).indexOf); +var hiddenKeys = __webpack_require__(2993); + +var push = uncurryThis([].push); + +module.exports = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn(O, key = names[i++])) { + ~indexOf(result, key) || push(result, key); + } + return result; +}; + + +/***/ }, + +/***/ 9428 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var internalObjectKeys = __webpack_require__(3120); +var enumBugKeys = __webpack_require__(2555); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +module.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); +}; + + +/***/ }, + +/***/ 4961 +(__unused_webpack_module, exports) { + +"use strict"; + +var $propertyIsEnumerable = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable; + + +/***/ }, + +/***/ 443 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable no-proto -- safe */ +var uncurryThisAccessor = __webpack_require__(4494); +var isObject = __webpack_require__(3598); +var requireObjectCoercible = __webpack_require__(5034); +var aPossiblePrototype = __webpack_require__(7222); + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + requireObjectCoercible(O); + aPossiblePrototype(proto); + if (!isObject(O)) return O; + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + + +/***/ }, + +/***/ 290 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8993); +var isCallable = __webpack_require__(8681); +var isObject = __webpack_require__(3598); + +var $TypeError = TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +module.exports = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; + if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val; + if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; + throw new $TypeError("Can't convert object to primitive value"); +}; + + +/***/ }, + +/***/ 7523 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var getBuiltIn = __webpack_require__(7139); +var uncurryThis = __webpack_require__(1212); +var getOwnPropertyNamesModule = __webpack_require__(5412); +var getOwnPropertySymbolsModule = __webpack_require__(4073); +var anObject = __webpack_require__(2091); + +var concat = uncurryThis([].concat); + +// all object keys, includes non-enumerable and symbols +module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys; +}; + + +/***/ }, + +/***/ 5034 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var isNullOrUndefined = __webpack_require__(6297); + +var $TypeError = TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +module.exports = function (it) { + if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it); + return it; +}; + + +/***/ }, + +/***/ 7099 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var shared = __webpack_require__(997); +var uid = __webpack_require__(6044); + +var keys = shared('keys'); + +module.exports = function (key) { + return keys[key] || (keys[key] = uid(key)); +}; + + +/***/ }, + +/***/ 3793 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var IS_PURE = __webpack_require__(7695); +var globalThis = __webpack_require__(7756); +var defineGlobalProperty = __webpack_require__(7309); + +var SHARED = '__core-js_shared__'; +var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {}); + +(store.versions || (store.versions = [])).push({ + version: '3.49.0', + mode: IS_PURE ? 'pure' : 'global', + copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.', + license: 'https://github.com/zloirock/core-js/blob/v3.49.0/LICENSE', + source: 'https://github.com/zloirock/core-js' +}); + + +/***/ }, + +/***/ 997 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var store = __webpack_require__(3793); + +module.exports = function (key, value) { + return store[key] || (store[key] = value || {}); +}; + + +/***/ }, + +/***/ 4483 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION = __webpack_require__(2227); +var fails = __webpack_require__(299); +var globalThis = __webpack_require__(7756); + +var $String = globalThis.String; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +module.exports = !!Object.getOwnPropertySymbols && !fails(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION && V8_VERSION < 41; +}); + + +/***/ }, + +/***/ 4918 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(2119); + +var max = Math.max; +var min = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +module.exports = function (index, length) { + var integer = toIntegerOrInfinity(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); +}; + + +/***/ }, + +/***/ 3018 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toPrimitive = __webpack_require__(3301); + +var $TypeError = TypeError; + +// `ToBigInt` abstract operation +// https://tc39.es/ecma262/#sec-tobigint +module.exports = function (argument) { + var prim = toPrimitive(argument, 'number'); + if (typeof prim == 'number') throw new $TypeError("Can't convert number to bigint"); + // eslint-disable-next-line es/no-bigint -- safe + return BigInt(prim); +}; + + +/***/ }, + +/***/ 5137 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject = __webpack_require__(2203); +var requireObjectCoercible = __webpack_require__(5034); + +module.exports = function (it) { + return IndexedObject(requireObjectCoercible(it)); +}; + + +/***/ }, + +/***/ 2119 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var trunc = __webpack_require__(2537); + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +module.exports = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); +}; + + +/***/ }, + +/***/ 8266 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(2119); + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +module.exports = function (argument) { + var len = toIntegerOrInfinity(argument); + return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + + +/***/ }, + +/***/ 3297 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var requireObjectCoercible = __webpack_require__(5034); + +var $Object = Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +module.exports = function (argument) { + return $Object(requireObjectCoercible(argument)); +}; + + +/***/ }, + +/***/ 4001 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toPositiveInteger = __webpack_require__(7866); + +var $RangeError = RangeError; + +module.exports = function (it, BYTES) { + var offset = toPositiveInteger(it); + if (offset % BYTES) throw new $RangeError('Wrong offset'); + return offset; +}; + + +/***/ }, + +/***/ 7866 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toIntegerOrInfinity = __webpack_require__(2119); + +var $RangeError = RangeError; + +module.exports = function (it) { + var result = toIntegerOrInfinity(it); + if (result < 0) throw new $RangeError("The argument can't be less than 0"); + return result; +}; + + +/***/ }, + +/***/ 3301 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var call = __webpack_require__(8993); +var isObject = __webpack_require__(3598); +var isSymbol = __webpack_require__(5985); +var getMethod = __webpack_require__(9738); +var ordinaryToPrimitive = __webpack_require__(290); +var wellKnownSymbol = __webpack_require__(8663); + +var $TypeError = TypeError; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +module.exports = function (input, pref) { + if (!isObject(input) || isSymbol(input)) return input; + var exoticToPrim = getMethod(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call(exoticToPrim, input, pref); + if (!isObject(result) || isSymbol(result)) return result; + throw new $TypeError("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + + +/***/ }, + +/***/ 1413 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var toPrimitive = __webpack_require__(3301); +var isSymbol = __webpack_require__(5985); + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +module.exports = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; +}; + + +/***/ }, + +/***/ 7920 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var wellKnownSymbol = __webpack_require__(8663); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var test = {}; +// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation +test[TO_STRING_TAG] = 'z'; + +module.exports = String(test) === '[object z]'; + + +/***/ }, + +/***/ 8819 +(module) { + +"use strict"; + +var $String = String; + +module.exports = function (argument) { + try { + return $String(argument); + } catch (error) { + return 'Object'; + } +}; + + +/***/ }, + +/***/ 6044 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var uncurryThis = __webpack_require__(1212); + +var id = 0; +var postfix = Math.random(); +var toString = uncurryThis(1.1.toString); + +module.exports = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36); +}; + + +/***/ }, + +/***/ 8300 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL = __webpack_require__(4483); + +module.exports = NATIVE_SYMBOL && + !Symbol.sham && + typeof Symbol.iterator == 'symbol'; + + +/***/ }, + +/***/ 2538 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(5144); +var fails = __webpack_require__(299); + +// V8 ~ Chrome 36- +// https://bugs.chromium.org/p/v8/issues/detail?id=3334 +module.exports = DESCRIPTORS && fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; +}); + + +/***/ }, + +/***/ 1194 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var isCallable = __webpack_require__(8681); + +var WeakMap = globalThis.WeakMap; + +module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap)); + + +/***/ }, + +/***/ 8663 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var shared = __webpack_require__(997); +var hasOwn = __webpack_require__(6341); +var uid = __webpack_require__(6044); +var NATIVE_SYMBOL = __webpack_require__(4483); +var USE_SYMBOL_AS_UID = __webpack_require__(8300); + +var Symbol = globalThis.Symbol; +var WellKnownSymbolsStore = shared('wks'); +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid; + +module.exports = function (name) { + if (!hasOwn(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name) + ? Symbol[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + + +/***/ }, + +/***/ 187 +(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var $ = __webpack_require__(3762); +var $includes = (__webpack_require__(789).includes); +var fails = __webpack_require__(299); +var addToUnscopables = __webpack_require__(1825); + +// FF99+ bug +var BROKEN_ON_SPARSE = fails(function () { + // eslint-disable-next-line es/no-array-prototype-includes -- detection + return !Array(1).includes(); +}); + +// Safari 26.4- bug +var BROKEN_ON_SPARSE_WITH_FROM_INDEX = fails(function () { + // eslint-disable-next-line no-sparse-arrays, es/no-array-prototype-includes -- detection + return [, 1].includes(undefined, 1); +}); + +// `Array.prototype.includes` method +// https://tc39.es/ecma262/#sec-array.prototype.includes +$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE || BROKEN_ON_SPARSE_WITH_FROM_INDEX }, { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('includes'); + + +/***/ }, + +/***/ 8376 +(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var ArrayBufferViewCore = __webpack_require__(4074); +var $fill = __webpack_require__(3161); +var toBigInt = __webpack_require__(3018); +var classof = __webpack_require__(9391); +var call = __webpack_require__(8993); +var uncurryThis = __webpack_require__(1212); +var fails = __webpack_require__(299); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var slice = uncurryThis(''.slice); + +// V8 ~ Chrome < 59, Safari < 14.1, FF < 55, Edge <=18 +var CONVERSION_BUG = fails(function () { + var count = 0; + // eslint-disable-next-line es/no-typed-arrays -- safe + new Int8Array(2).fill({ valueOf: function () { return count++; } }); + return count !== 1; +}); + +// `%TypedArray%.prototype.fill` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill +exportTypedArrayMethod('fill', function fill(value /* , start, end */) { + var length = arguments.length; + aTypedArray(this); + var actualValue = slice(classof(this), 0, 3) === 'Big' ? toBigInt(value) : +value; + return call($fill, this, actualValue, length > 1 ? arguments[1] : undefined, length > 2 ? arguments[2] : undefined); +}, CONVERSION_BUG); + + +/***/ }, + +/***/ 6401 +(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var call = __webpack_require__(8993); +var ArrayBufferViewCore = __webpack_require__(4074); +var lengthOfArrayLike = __webpack_require__(4730); +var toOffset = __webpack_require__(4001); +var toIndexedObject = __webpack_require__(3297); +var fails = __webpack_require__(299); + +var RangeError = globalThis.RangeError; +var Int8Array = globalThis.Int8Array; +var Int8ArrayPrototype = Int8Array && Int8Array.prototype; +var $set = Int8ArrayPrototype && Int8ArrayPrototype.set; +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; + +var WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS = !fails(function () { + // eslint-disable-next-line es/no-typed-arrays -- required for testing + var array = new Uint8ClampedArray(2); + call($set, array, { length: 1, 0: 3 }, 1); + return array[1] !== 3; +}); + +// https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other +var TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS && fails(function () { + var array = new Int8Array(2); + array.set(1); + array.set('2', 1); + return array[0] !== 0 || array[1] !== 2; +}); + +// `%TypedArray%.prototype.set` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.set +exportTypedArrayMethod('set', function set(arrayLike /* , offset */) { + aTypedArray(this); + var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1); + var src = toIndexedObject(arrayLike); + if (WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS) return call($set, this, src, offset); + var length = this.length; + var len = lengthOfArrayLike(src); + var index = 0; + if (len + offset > length) throw new RangeError('Wrong length'); + while (index < len) this[offset + index] = src[index++]; +}, !WORKS_WITH_OBJECTS_AND_GENERIC_ON_TYPED_ARRAYS || TO_OBJECT_BUG); + + +/***/ }, + +/***/ 2017 +(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + +var globalThis = __webpack_require__(7756); +var uncurryThis = __webpack_require__(5336); +var fails = __webpack_require__(299); +var aCallable = __webpack_require__(1078); +var internalSort = __webpack_require__(644); +var ArrayBufferViewCore = __webpack_require__(4074); +var FF = __webpack_require__(5337); +var IE_OR_EDGE = __webpack_require__(7383); +var V8 = __webpack_require__(2227); +var WEBKIT = __webpack_require__(4507); + +var aTypedArray = ArrayBufferViewCore.aTypedArray; +var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod; +var Uint16Array = globalThis.Uint16Array; +var nativeSort = Uint16Array && uncurryThis(Uint16Array.prototype.sort); + +// WebKit +var ACCEPT_INCORRECT_ARGUMENTS = !!nativeSort && !(fails(function () { + nativeSort(new Uint16Array(2), null); +}) && fails(function () { + nativeSort(new Uint16Array(2), {}); +})); + +var STABLE_SORT = !!nativeSort && !fails(function () { + // feature detection can be too slow, so check engines versions + if (V8) return V8 < 74; + if (FF) return FF < 67; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 602; + + var array = new Uint16Array(516); + var expected = Array(516); + var index, mod; + + for (index = 0; index < 516; index++) { + mod = index % 4; + array[index] = 515 - index; + expected[index] = index - 2 * mod + 3; + } + + nativeSort(array, function (a, b) { + return (a / 4 | 0) - (b / 4 | 0); + }); + + for (index = 0; index < 516; index++) { + if (array[index] !== expected[index]) return true; + } +}); + +var getSortCompare = function (comparefn) { + return function (x, y) { + if (comparefn !== undefined) return +comparefn(x, y) || 0; + // eslint-disable-next-line no-self-compare -- NaN check + if (y !== y) return x !== x ? 0 : -1; + // eslint-disable-next-line no-self-compare -- NaN check + if (x !== x) return 1; + if (x === 0 && y === 0) return 1 / x > 0 ? (1 / y > 0 ? 0 : 1) : (1 / y > 0 ? -1 : 0); + return x > y ? 1 : x < y ? -1 : 0; + }; +}; + +// `%TypedArray%.prototype.sort` method +// https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort +exportTypedArrayMethod('sort', function sort(comparefn) { + if (comparefn !== undefined) aCallable(comparefn); + if (STABLE_SORT) return nativeSort(this, comparefn); + + return internalSort(aTypedArray(this), getSortCompare(comparefn)); +}, !STABLE_SORT || ACCEPT_INCORRECT_ARGUMENTS); + + +/***/ }, + +/***/ 1715 +(module, __unused_webpack_exports, __webpack_require__) { + +var $gfJaN$restructure = __webpack_require__(5233); +var $gfJaN$swchelperscjs_define_propertycjs = __webpack_require__(4415); +var $gfJaN$swchelperscjs_ts_decoratecjs = __webpack_require__(8395); +var $gfJaN$fastdeepequal = __webpack_require__(453); +var $gfJaN$unicodeproperties = __webpack_require__(4766); +var $gfJaN$unicodetrie = __webpack_require__(7571); +var $gfJaN$dfa = __webpack_require__(4406); +var $gfJaN$clone = __webpack_require__(1613); +var $gfJaN$tinyinflate = __webpack_require__(3483); +var $gfJaN$brotlidecompressjs = __webpack_require__(4460); + + +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 syllable +const $fa1d9fd80dd7279e$var$LVT = 5; // Composed 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: + [ + [ + $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: or + [ + [ + $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: or + [ + [ + $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 = prev; + tjmo = glyph; + } else { + if (type === $fa1d9fd80dd7279e$var$V) { + // + ljmo = glyphs[i - 1]; + vjmo = glyph; + } else { + // + 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 , 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 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 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); + + + + +/***/ }, + +/***/ 2532 +(module, __unused_webpack_exports, __webpack_require__) { + +var $kQ2hT$unicodetrie = __webpack_require__(7571); +var $kQ2hT$base64js = __webpack_require__(3915); + +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; + + + + +/***/ }, + +/***/ 381 +(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/* provided dependency */ var Buffer = __webpack_require__(783)["Buffer"]; + + +var zlib = __webpack_require__(6729); + +function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; } + +var zlib__default = /*#__PURE__*/_interopDefaultCompat(zlib); + +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 = Buffer.from(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 zlib__default.default.inflate(this.imgData, (err, data) => { + if (err) { + throw err; + } + + const { width, height } = this; + const pixelBytes = this.pixelBitlength / 8; + + const pixels = Buffer.alloc(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 : Buffer.alloc(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 = Buffer.alloc(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 = Buffer.alloc(this.width * this.height * 4); + return this.decodePixels(pixels => { + this.copyToImageData(ret, pixels); + return fn(ret); + }); + } +} + +module.exports = PNG; + + +/***/ }, + +/***/ 5233 +(module) { + + +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); + + + + +/***/ }, + +/***/ 4766 +(module, __unused_webpack_exports, __webpack_require__) { + +var $c5L0i$base64js = __webpack_require__(2504); +var $c5L0i$unicodetrie = __webpack_require__(7571); + +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("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")); +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 +}; + + + + +/***/ }, + +/***/ 7507 +(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.XmlDocument = exports.XmlElement = exports.XmlCommentNode = exports.XmlCDataNode = exports.XmlTextNode = void 0; +const sax_1 = __importDefault(__webpack_require__(1733)); +/** + * Represents a text node in an XML document + */ +class XmlTextNode { + /** + * Creates a new text node + * @param text The text content + */ + constructor(text) { + this.text = text; + this.type = "text"; + } + /** + * Converts the text node to a string + * @param options Formatting options + * @returns String representation of the text node + */ + toString(options) { + return formatText(escapeXML(this.text), options); + } + /** + * Converts the text node to a string with indentation + * @param indent The indentation to use + * @param options Formatting options + * @returns String representation of the text node with indentation + */ + toStringWithIndent(indent, options) { + return indent + this.toString(options); + } +} +exports.XmlTextNode = XmlTextNode; +/** + * Represents a CDATA node in an XML document + */ +class XmlCDataNode { + /** + * Creates a new CDATA node + * @param cdata The CDATA content + */ + constructor(cdata) { + this.cdata = cdata; + this.type = "cdata"; + } + /** + * Converts the CDATA node to a string + * @param options Formatting options + * @returns String representation of the CDATA node + */ + toString(options) { + return ``; + } + /** + * Converts the CDATA node to a string with indentation + * @param indent The indentation to use + * @param options Formatting options + * @returns String representation of the CDATA node with indentation + */ + toStringWithIndent(indent, options) { + return indent + this.toString(options); + } +} +exports.XmlCDataNode = XmlCDataNode; +/** + * Represents a comment node in an XML document + */ +class XmlCommentNode { + /** + * Creates a new comment node + * @param comment The comment content + */ + constructor(comment) { + this.comment = comment; + this.type = "comment"; + } + /** + * Converts the comment node to a string + * @param options Formatting options + * @returns String representation of the comment node + */ + toString(options) { + return ``; + } + /** + * Converts the comment node to a string with indentation + * @param indent The indentation to use + * @param options Formatting options + * @returns String representation of the comment node with indentation + */ + toStringWithIndent(indent, options) { + return indent + this.toString(options); + } +} +exports.XmlCommentNode = XmlCommentNode; +/** + * Represents an XML element node with children + */ +class XmlElement { + /** + * Creates a new XML element + * @param tag The tag name and attributes + * @param parser Optional SAX parser instance with position information + */ + constructor(tag, parser) { + this.type = "element"; + // If you didn't hand us a parser (common case) see if we can grab one + // from the current execution stack. + if (!parser && delegates.length) { + var delegate = delegates[delegates.length - 1]; + if ("parser" in delegate) { + parser = delegate.parser; + } + } + this.name = tag.name; + this.attr = tag.attributes; + this.val = ""; + this.children = []; + this.firstChild = null; + this.lastChild = null; + // Assign parse information + this.line = parser ? parser.line : null; + this.column = parser ? parser.column : null; + this.position = parser ? parser.position : null; + this.startTagPosition = parser ? parser.startTagPosition : null; + } + /** + * Adds a child node to this element + * @param child The child node to add + */ + _addChild(child) { + // add to our children array + this.children.push(child); + // update first/last pointers + if (!this.firstChild) + this.firstChild = child; + this.lastChild = child; + } + _opentag(tag) { + const child = new XmlElement(tag); + this._addChild(child); + delegates.unshift(child); + } + _closetag() { + delegates.shift(); + } + _text(text) { + this.val += text; + this._addChild(new XmlTextNode(text)); + } + _cdata(cdata) { + this.val += cdata; + this._addChild(new XmlCDataNode(cdata)); + } + _comment(comment) { + this._addChild(new XmlCommentNode(comment)); + } + _error(err) { + throw err; + } + /** + * Iterates through each child element of this node + * @param iterator Function to call for each child element + * @param context Optional context to use for the iterator function + */ + eachChild(iterator, context) { + for (let i = 0, l = this.children.length; i < l; i++) { + const child = this.children[i]; + if (child.type === "element") { + if (iterator.call(context, child, i, this.children) === + false) + return; + } + } + } + /** + * Finds the first child element with the given name + * @param name The name of the child element to find + * @returns The first matching child element, or undefined if not found + */ + childNamed(name) { + for (let i = 0, l = this.children.length; i < l; i++) { + const child = this.children[i]; + if (child.type === "element" && child.name === name) { + return child; + } + } + return undefined; + } + /** + * Finds all child elements with the given name + * @param name The name of the child elements to find + * @returns Array of matching child elements + */ + childrenNamed(name) { + const matches = []; + for (let i = 0, l = this.children.length; i < l; i++) { + const child = this.children[i]; + if (child.type === "element" && child.name === name) { + matches.push(child); + } + } + return matches; + } + /** + * Finds the first child element with the given attribute + * @param name The name of the attribute to find + * @param value Optional value the attribute should have + * @returns The first matching child element, or undefined if not found + */ + childWithAttribute(name, value) { + for (let i = 0, l = this.children.length; i < l; i++) { + const child = this.children[i]; + if (child.type === "element" && + ((value !== undefined && child.attr[name] === value) || + (value === undefined && child.attr[name]))) { + return child; + } + } + return undefined; + } + /** + * Finds all descendant elements with the given name, searching recursively + * @param name The name of the descendant elements to find + * @returns Array of matching descendant elements + */ + descendantsNamed(name) { + const matches = []; + for (let i = 0, l = this.children.length; i < l; i++) { + const child = this.children[i]; + if (child.type === "element") { + const element = child; + if (element.name === name) + matches.push(element); + matches.push(...element.descendantsNamed(name)); + } + } + return matches; + } + /** + * Finds a descendant element using a dot-notation path + * @param path The path to the descendant, e.g. "author.name" + * @returns The matching descendant element, or undefined if not found + * @example + * // For XML: John + * bookNode.descendantWithPath("author.name") // returns the element + */ + descendantWithPath(path) { + let descendant = this; + const components = path.split("."); + for (let i = 0, l = components.length; i < l; i++) { + if (descendant && descendant.type === "element") { + descendant = descendant.childNamed(components[i]); + } + else { + return undefined; + } + } + return descendant; + } + /** + * Gets the value of a descendant element or attribute using a path + * @param path The path to the descendant or attribute, e.g. "author.name" or "author.name@id" + * @returns The value of the descendant or attribute, or undefined if not found + * @example + * // For XML: John + * bookNode.valueWithPath("author.name") // returns "John" + * bookNode.valueWithPath("author.name@id") // returns "1" + */ + valueWithPath(path) { + const components = path.split("@"); + const descendant = this.descendantWithPath(components[0]); + if (descendant) { + return components.length > 1 + ? descendant.attr[components[1]] + : descendant.val; + } + else { + return undefined; + } + } + /** + * Converts the element to a string representation + * @param options Formatting options + * @returns String representation of the element + */ + toString(options) { + return this.toStringWithIndent("", options); + } + /** + * Converts the element to a string with the specified indentation + * @param indent The indentation to use + * @param options Formatting options + * @returns String representation of the element with indentation + */ + toStringWithIndent(indent, options) { + let s = `${indent}<${this.name}`; + const linebreak = (options === null || options === void 0 ? void 0 : options.compressed) ? "" : "\n"; + for (const name in this.attr) { + if (Object.prototype.hasOwnProperty.call(this.attr, name)) { + s += ` ${name}="${escapeXML(this.attr[name])}"`; + } + } + if (this.children.length === 1 && this.children[0].type !== "element") { + s += `>${this.children[0].toString(options)}`; + } + else if (this.children.length) { + s += `>${linebreak}`; + const childIndent = indent + ((options === null || options === void 0 ? void 0 : options.compressed) ? "" : " "); + for (let i = 0, l = this.children.length; i < l; i++) { + s += `${this.children[i].toStringWithIndent(childIndent, options)}${linebreak}`; + } + s += `${indent}`; + } + else if (options === null || options === void 0 ? void 0 : options.html) { + const whiteList = [ + "area", + "base", + "br", + "col", + "embed", + "frame", + "hr", + "img", + "input", + "keygen", + "link", + "menuitem", + "meta", + "param", + "source", + "track", + "wbr", + ]; + if (whiteList.includes(this.name)) { + s += "/>"; + } + else { + s += `>`; + } + } + else { + s += "/>"; + } + return s; + } +} +exports.XmlElement = XmlElement; +/** + * The main XML document class - the entry point for parsing XML + */ +class XmlDocument extends XmlElement { + /** + * Creates a new XML document from an XML string + * @param xml The XML string to parse + * @throws {Error} If the XML is empty or invalid + * @example + * ```ts + * import { XmlDocument } from 'xmldoc'; + * + * const doc = new XmlDocument("value"); + * console.log(doc.childNamed("child")?.val); // "value" + * ``` + */ + constructor(xml) { + // Initialize with a dummy tag that will be replaced + super({ name: "", attributes: {} }); + xml = xml.toString().trim(); + if (!xml) { + throw new Error("No XML to parse!"); + } + // Stores doctype (if defined) + this.doctype = ""; + // Expose the parser to the other delegates while the parser is running + this.parser = sax_1.default.parser(true); // strict + addParserEvents(this.parser); + // Initialize delegates with this document + delegates = [this]; + try { + this.parser.write(xml); + } + finally { + // Remove the parser as it is no longer needed + delete this.parser; + } + } + _opentag(tag) { + if (this.name === "") { + // First tag becomes the root - we'll update our own properties + this.name = tag.name; + this.attr = tag.attributes; + } + else { + // All other tags will be the root element's children + super._opentag(tag); + } + } + _doctype(doctype) { + this.doctype += doctype; + } +} +exports.XmlDocument = XmlDocument; +// Helper variables and functions +let delegates = []; +function addParserEvents(parser) { + parser.onopentag = (tag) => { var _a; return (_a = delegates[0]) === null || _a === void 0 ? void 0 : _a._opentag(tag); }; + parser.onclosetag = () => { var _a; return (_a = delegates[0]) === null || _a === void 0 ? void 0 : _a._closetag(); }; + parser.ontext = (text) => { var _a; return (_a = delegates[0]) === null || _a === void 0 ? void 0 : _a._text(text); }; + parser.oncdata = (cdata) => { var _a; return (_a = delegates[0]) === null || _a === void 0 ? void 0 : _a._cdata(cdata); }; + parser.oncomment = (comment) => { var _a; return (_a = delegates[0]) === null || _a === void 0 ? void 0 : _a._comment(comment); }; + parser.ondoctype = (doctype) => { + const doc = delegates[0]; + if (doc._doctype) + doc._doctype(doctype); + }; + parser.onerror = (err) => { var _a; return (_a = delegates[0]) === null || _a === void 0 ? void 0 : _a._error(err); }; +} +/** + * Escapes XML special characters + * @param value The string to escape + * @returns The escaped string + */ +function escapeXML(value) { + return value + .toString() + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/'/g, "'") + .replace(/"/g, """); +} +/** + * Formats text for display according to the given options + * @param text The text to format + * @param options Formatting options + * @returns The formatted text + */ +function formatText(text, options) { + let finalText = text; + if ((options === null || options === void 0 ? void 0 : options.trimmed) && text.length > 25) { + finalText = finalText.substring(0, 25).trim() + "…"; + } + if (!(options === null || options === void 0 ? void 0 : options.preserveWhitespace)) { + finalText = finalText.trim(); + } + return finalText; +} +// Export main classes +exports["default"] = XmlDocument; + + +/***/ }, + +/***/ 1635 +(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) { + +"use strict"; +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ __decorate: () => (/* binding */ __decorate) +/* harmony export */ }); +/* unused harmony exports __extends, __assign, __rest, __param, __esDecorate, __runInitializers, __propKey, __setFunctionName, __metadata, __awaiter, __generator, __createBinding, __exportStar, __values, __read, __spread, __spreadArrays, __spreadArray, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault, __classPrivateFieldGet, __classPrivateFieldSet, __classPrivateFieldIn, __addDisposableResource, __disposeResources, __rewriteRelativeImportExtension */ +/****************************************************************************** +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 Reflect, Promise, SuppressedError, Symbol, Iterator */ + +var extendStatics = function(d, b) { + 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]; }; + return extendStatics(d, b); +}; + +function __extends(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 __()); +} + +var __assign = function() { + __assign = Object.assign || function __assign(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; + } + return __assign.apply(this, arguments); +} + +function __rest(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; +} + +function __decorate(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; +} + +function __param(paramIndex, decorator) { + return function (target, key) { decorator(target, key, paramIndex); } +} + +function __esDecorate(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; +}; + +function __runInitializers(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; +}; + +function __propKey(x) { + return typeof x === "symbol" ? x : "".concat(x); +}; + +function __setFunctionName(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 }); +}; + +function __metadata(metadataKey, metadataValue) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue); +} + +function __awaiter(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()); + }); +} + +function __generator(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 }; + } +} + +var __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]; +}); + +function __exportStar(m, o) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p); +} + +function __values(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."); +} + +function __read(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 */ +function __spread() { + for (var ar = [], i = 0; i < arguments.length; i++) + ar = ar.concat(__read(arguments[i])); + return ar; +} + +/** @deprecated */ +function __spreadArrays() { + 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; +} + +function __spreadArray(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)); +} + +function __await(v) { + return this instanceof __await ? (this.v = v, this) : new __await(v); +} + +function __asyncGenerator(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]); } +} + +function __asyncDelegator(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; } +} + +function __asyncValues(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); } +} + +function __makeTemplateObject(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); +}; + +function __importStar(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; +} + +function __importDefault(mod) { + return (mod && mod.__esModule) ? mod : { default: mod }; +} + +function __classPrivateFieldGet(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); +} + +function __classPrivateFieldSet(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; +} + +function __classPrivateFieldIn(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); +} + +function __addDisposableResource(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; +}; + +function __disposeResources(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(); +} + +function __rewriteRelativeImportExtension(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; +} + +/* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ({ + __extends, + __assign, + __rest, + __decorate, + __param, + __esDecorate, + __runInitializers, + __propKey, + __setFunctionName, + __metadata, + __awaiter, + __generator, + __createBinding, + __exportStar, + __values, + __read, + __spread, + __spreadArrays, + __spreadArray, + __await, + __asyncGenerator, + __asyncDelegator, + __asyncValues, + __makeTemplateObject, + __importStar, + __importDefault, + __classPrivateFieldGet, + __classPrivateFieldSet, + __classPrivateFieldIn, + __addDisposableResource, + __disposeResources, + __rewriteRelativeImportExtension, +}); + + +/***/ } + +/******/ }); +/************************************************************************/ +/******/ // The module cache +/******/ var __webpack_module_cache__ = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ // Check if module is in cache +/******/ var cachedModule = __webpack_module_cache__[moduleId]; +/******/ if (cachedModule !== undefined) { +/******/ return cachedModule.exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = __webpack_module_cache__[moduleId] = { +/******/ id: moduleId, +/******/ loaded: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.loaded = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/************************************************************************/ +/******/ /* webpack/runtime/amd options */ +/******/ (() => { +/******/ __webpack_require__.amdO = {}; +/******/ })(); +/******/ +/******/ /* webpack/runtime/compat get default export */ +/******/ (() => { +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = (module) => { +/******/ var getter = module && module.__esModule ? +/******/ () => (module['default']) : +/******/ () => (module); +/******/ __webpack_require__.d(getter, { a: getter }); +/******/ return getter; +/******/ }; +/******/ })(); +/******/ +/******/ /* webpack/runtime/define property getters */ +/******/ (() => { +/******/ // define getter functions for harmony exports +/******/ __webpack_require__.d = (exports, definition) => { +/******/ for(var key in definition) { +/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { +/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); +/******/ } +/******/ } +/******/ }; +/******/ })(); +/******/ +/******/ /* webpack/runtime/global */ +/******/ (() => { +/******/ __webpack_require__.g = (function() { +/******/ if (typeof globalThis === 'object') return globalThis; +/******/ try { +/******/ return this || new Function('return this')(); +/******/ } catch (e) { +/******/ if (typeof window === 'object') return window; +/******/ } +/******/ })(); +/******/ })(); +/******/ +/******/ /* webpack/runtime/hasOwnProperty shorthand */ +/******/ (() => { +/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) +/******/ })(); +/******/ +/******/ /* webpack/runtime/node module decorator */ +/******/ (() => { +/******/ __webpack_require__.nmd = (module) => { +/******/ module.paths = []; +/******/ if (!module.children) module.children = []; +/******/ return module; +/******/ }; +/******/ })(); +/******/ +/************************************************************************/ +/******/ +/******/ // startup +/******/ // Load entry module and return exports +/******/ // This entry module is referenced by other modules so it can't be inlined +/******/ var __webpack_exports__ = __webpack_require__(6092); +/******/ +/******/ return __webpack_exports__; +/******/ })() +; +}); +//# sourceMappingURL=pdfmake.js.map \ No newline at end of file diff --git a/credentials/html-render-method-pdfmake/queries.json b/credentials/html-render-method-pdfmake/queries.json new file mode 100644 index 0000000..5a871d7 --- /dev/null +++ b/credentials/html-render-method-pdfmake/queries.json @@ -0,0 +1,26 @@ +{ + "default": { + "type": "QueryByExample", + "credentialQuery": { + "reason": "Please present your Name Credential with HTML Render Method.", + "example": { + "@context": [ + "https://www.w3.org/2018/credentials/v1", + "https://www.w3.org/ns/credentials/examples/v2" + ], + "type": ["NameCredential"], + "renderMethod": { + "type": "TemplateRenderMethod", + "renderSuite": "html" + } + }, + "acceptedCryptosuites": [ + "Ed25519Signature2020", + "eddsa-rdfc-2022", + "ecdsa-rdfc-2019", + "bbs-2023", + "ecdsa-sd-2023" + ] + } + } +} diff --git a/credentials/html-render-method-pdfmake/template-credential.json b/credentials/html-render-method-pdfmake/template-credential.json new file mode 100644 index 0000000..6125ef8 --- /dev/null +++ b/credentials/html-render-method-pdfmake/template-credential.json @@ -0,0 +1,38 @@ +{ + "@context": [ + "https://www.w3.org/ns/credentials/v2", + "https://www.w3.org/ns/credentials/examples/v2" + ], + "type": [ + "VerifiableCredential", + "NameCredential" + ], + "issuer": { + "id": "did:example:1234", + "name": "The Issuer" + }, + "credentialSubject": { + "id": "did:example:ABCD", + "name": "Example Name", + "notRendered": "should not appear" + }, + "renderMethod": { + "type": "TemplateRenderMethod", + "renderSuite": "html", + "renderProperty": [ + "/issuer/name", + "/credentialSubject/name" + ], + "template": "data:text/html,[[template]]", + "outputPreference": { + "mode": [ + "visual" + ], + "mediaType": "application/pdf", + "style": { + "width": "800px", + "height": "800px" + } + } + } +} diff --git a/credentials/html-render-method-pdfmake/template.html b/credentials/html-render-method-pdfmake/template.html new file mode 100644 index 0000000..028ef1b --- /dev/null +++ b/credentials/html-render-method-pdfmake/template.html @@ -0,0 +1,46 @@ +
+ + + + +
+

{{credentialSubject-name}}

+

Issued by: {{ issuer-name }}

+
+
+ +
diff --git a/credentials/html-render-method-pdfmake/vfs_fonts.v0.3.8.js b/credentials/html-render-method-pdfmake/vfs_fonts.v0.3.8.js new file mode 100644 index 0000000..4be8805 --- /dev/null +++ b/credentials/html-render-method-pdfmake/vfs_fonts.v0.3.8.js @@ -0,0 +1,6 @@ +var vfs = { + "Roboto-Italic.ttf": "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", + "Roboto-Medium.ttf": "AAEAAAARAQAABAAQR0RFRqcXo6wAAcUkAAACWEdQT1PZu1sbAAHHfAAAiWpHU1VCzONMagACUOgAABXoT1MvMpfnsZMAAAGYAAAAYGNtYXAi3dtfAAAWsAAABqZjdnQgO/gmfQAAL7AAAAD+ZnBnbagFhDIAAB1YAAAPhmdhc3AACAAZAAHFGAAAAAxnbHlmG1U/IQAAOxAAAYYCaGVhZA0GDRkAAAEcAAAANmhoZWEK9hLmAAABVAAAACRobXR4WrZbwgAAAfgAABS4bG9jYYlXJ1YAADCwAAAKXm1heHAI3hDGAAABeAAAACBuYW1lYaKOkgABwRQAAAPicG9zdP9tAGQAAcT4AAAAIHByZXB5WM7TAAAs4AAAAs4AAQAAAAMDll+R1PFfDzz1ABsIAAAAAADE8BEuAAAAAOVdrQ/6Jv3VCWEIcwAAAAkAAgAAAAAAAAABAAAHbP4MAAAJbvom/j4JYQgAAAAAAAAAAAAAAAAAAAAFLgABAAAFLgCpABUAdgAHAAIAEAAvAJoAAALmD3UAAwABAAQEkQH0AAUAAAWaBTMAAAEfBZoFMwAAA9EAZgIAAAACAAAAAAAAAAAA4AAC/1AAIFsAAAAgAAAAAEdPT0cAQAAA//0GAP4AAGYHmgIAIAABnwAAAAAEOgWwAAAAIAADA4wAZAAAAAAAAAAAAf0AAAH9AAACHgCMAo4AYATTAFYEjABkBeQAZAUhAFUBVwBSAsUAgQLMACcDjAAcBHEAQgHKACICuABQAjkAhgMfAAEEjABoBIwAqgSMAFIEjABOBIwANwSMAH8EjABzBIwARASMAGcEjABdAhwAfwHrADMEEgA+BIAAjwQoAH4D5AA7By0AWwVOABEFDQCUBTkAZgU5AJQEhQCUBGgAlAVzAGsFrQCUAkQApQRyAC8FDgCUBFIAlAb/AJQFrQCUBYMAZQUbAJQFgwBgBQkAlATYAEsE4AAtBTwAgAUqABEHCwAvBQ0AJgTjAAgE0wBQAiwAhQNVABICLAALA24ANgOVAAICkAA4BFAAVgR/AH0ELQBOBIIAUARJAFEC0wArBIkAUgRyAHoCCgB8AgL/qwQsAH0CCgCMBvgAfAR0AHoEigBOBH8AfQSHAFAC1AB9BB4ASQKqAAoEcwB3A/gAFgXwACMEBgAfA+sADAQGAFECqwA4Af0ArwKrABwFTQB1Ah8AhQSCAGcEtQBfBZ4AXARAAA0B+ACJBPkAXAOSAGMGSQBaA5AAjgPjAFcEawB/BkoAWQPaAJ0DDwCBBEoAXAL1AD0C9QA3ApQAbwTBAJMD6gBJAkQAkAITAGwC9QCCA6cAeQPjAF4FygBfBiIAUwZcAGYD5QBGB37//ARCAEwFgQBpBM8AlQTrAIoGwgBIBKQAaASRAEMEhgBOBJEAgQTsAFAFsAAfAhcAkASaAI0EZAAgAlIAIAWXAJAEhgB9B7AAZQc+AFkCBwCJBY0AVQLQ/94FkQBbBJ0ATQWjAIAE5gB3AiX/rgQ5AFcD3gCQA6oAbgPaAJ0DfgB1AgoAgQKqAHgCTAApA84AdwMoAEsCcwCJAAD8kwAA/WIAAPx0AAD9OgAA/AgAAP0eAmsAzQQ7AG4CRACQBHQAmQXCABoFegBcBTUAIASMAGoFrgCZBIwARwX5AEwFsQBGBVkAbASEAFYEyACXBA0AHgSGAFEEZQBiBA8AWQSGAH0EpwB2AqUAowRoABUEGgBnBPwAMASGAIAEMwBQBI4AUAQqADwEXQB/BdEARgXMAFIGlABlBLQAeASH/+EGeQArBf0AJAVTAGcIgQAtCIwAmQZRAC0FpQCPBQcAkAX9ACYHqQAVBNsASQWmAJIFqAAsBQsAMgZfAE4F+ACOBYUAkQeaAJUH+gCVBiEAFQbwAJkFAgCQBUgAYwdiAKEE6AAXBIAAWgSLAI8DWwCDBPIAJwaHACAEFwBOBJIAhARsAI8ElAAgBgIAjwSRAIQEkgCEA/oAIwXUAFMEzwCEBGUAYAaNAIQG8QB9BSEAIAZvAI8EaQCPBDkAUAaCAJIEcAAuBHL/1wQ5AFIG1gAdBuQAhASG/+gEkgCEB1gAiAZqAHIEaP/hBygAmAYCAIYFFgAaBGMACwdLAKwGPQCaBuUAfgXdAIEJKgClB+4AkAQgACgD9QAyBXoAYASIAE0FGAAQBA0AHgV6AGAEhgBOB1QAiAZWAHUHWACIBmoAcgUQAGcERwBdBPsAcAAA/HAAAPx1AAD9gQAA/aYAAPomAAD6UQYgAJIFEwCEBGj/4QUQAJQEhgB9BGsAjwOjAH0E6gCZBCQAfQgjABUG4AAgBckAmQT7AI8FLgCRBKwAjQaUADQFoAA8BiAAlAUHAIQH3QCUBa0AfQhJAJcG7wB9BjcAZwUEAGAFOQAmBEEAHwcoACkFbwAnBfIAkQTcAGAFcACBBHQAdQWFAIkGGwAKBMT/ywUgAJEEeACNBh8ALAUUACAFrQCZBIYAfQYqAJQFEQCEB3UAlAZ0AI8FjQBVBKMAWwSkAF0EwwAsA6oAIwVpACYEcQAfBPkATwbzAGgG2wBfBlEAPQUoAC8EgwBKBEgAcwe8AEIGpAA/B/UAlAaeAHQFBgBcBC8AVQWoACEFHQBEBU4AfQZGACwFOwAgBVAAdAMbAGQEFAAACCkAAAQUAAAIKQAAArkAAAIKAAABXAAABH8AAAIwAAABogAAAQAAAADRAAAAAAAAArcAUAK3AFAFIwCcBioAewOaAAgBvwBlAboANwHOADUBowBLAwsAbQMTAEQDAAA1BFsAPwSaAF0CzACKA/0AjQWqAI0BzwBeB64AUAJ0AGwCaQBVA5kAKwL1AEwC9QA2AvUAUAL1AE4C9QA3AvUASwL1AEcDOQBQAvMAUALzAFACAwBTAgMAUANcAGcC9QBMAvUAggL1AD0C9QA3AvUANgL1AFAC9QBOAvUANwL1AEsC9QBHAzkAUALzAFAC8wBQAgMAUwIDAFAEtQBiBm4AIwa/AJkIlQCUBjsAIwabAH0EjABcBeoAIwQtACoEmwAkBWIATwV+ACsF5ABuA+MARQgpAJAFCABvBRQAlgY3AFsG3gBWBtAAXgasAFwEkwBhBYoApgTeAD8EgACcBJ0AOwhSAGECMv+nBJEAZQSAAI8EEgA9BCgAfQQOACUCUQCcAo4AZAHpAEcFGQArBK0AGgS9ACsHKAArBygAKwUPACsGtwBJAAAAAAgwAFkINQBcAvUAPQL1AIIC9QBMBB0ATwQdAFcEHQA4BB0AXwQdAGYEHQAzBB0APQQdAEMEHQCYBB0AWAQrAEEEPgAGBFwAEwYJACcEeQAIBIgAaQQ/ACUENwA/BGQAdQS9AE0EawB2BL0ATgTcAHYGBQB2A7cAdgReAHYD1gAmAf4AhgTdAHYEpwBWA8gAdgQ3AD8EaAA6A6UACgO8AHYEeQAIBL0ATgR5AAgDnQBGBNkAdgQeAEQFpgBPBVgATwTgAF4FkgAjBIAATwdWACQHWAB2BZkAJQTYAHYEcgB2BV4AJwZFABsERgBDBOIAdgRdAHYEywAkBEwAHwViAHYEjQBDBoQAdgcOAHYFYQAJBhYAdgRnAHYEgAA9Bo8AdgSEAEIEKAALBqMAGwSgAHYFDQB2BXQAIQX4AE4EVgAGBMQAEwaXACMEjQBDBI0AdgYAAA4EzgBNBEcAQwS9AE4EaAA6A/QARQgtAHYE9AAoAvUANwL1ADYC9QBQAvUATgL1ADcC9QBLAvUARwO2AI0CrgCYA+AAdgQ6AAwEtgBWBUEAmQUoAJkEMACBBTUAmQQoAIEEegB2BIAATwRgAHYEmgAIAf4AkAOhAHUAAPyeA/cAegP6/1EECwB5A/oAeQO8AHYDnQB1A50AdQL1AEwC9QA2AvUAUAL1AE4C9QA3AvUASwL1AEcFcwBpBZ4AaQV/AJkF2QBpBdoAaQQoAJYEggBrBFgADwS7ADQEawBnBC4AQgOhAHYBugBiBpgATgSvAG4CDP+nBIwAOASMAGgEjAAsBIwAYgSMAF8EjAA0BIwAbASMAFkEjABnBIwA5QIm/64CJf+uAhcAkAIX//oCFwCQBGAAdgTmAGAEMAA5BIgAfQQ+AE8ElQBOBJEATgSdAEkEkgB9BJoATgRJAFEEiQBQBFkANAOtAGEFDABfA8QABQZG/+wEBwB2BL0ATgUOADQE3AB2Af0AAAK4AFAFVwAXBVcAFwSQ//UE4AAtAqr/6wVOABEFTgARBU4AEQVOABEFTgARBU4AEQVOABEFOQBmBIUAlASFAJQEhQCUBIUAlAJE/8sCRAClAkT/ygJE/74FrQCUBYMAZQWDAGUFgwBlBYMAZQWDAGUFPACABTwAgAU8AIAFPACABOMACARQAFYEUABWBFAAVgRQAFYEUABWBFAAVgRQAFYELQBOBEkAUQRJAFEESQBRBEkAUQIX/7QCFwCQAhf/tAIX/6gEdAB6BIoATgSKAE4EigBOBIoATgSKAE4EcwB3BHMAdwRzAHcEcwB3A+sADAPrAAwFTgARBFAAVgVOABEEUABWBU4AEQRQAFYFOQBmBC0ATgU5AGYELQBOBTkAZgQtAE4FOQBmBC0ATgU5AJQFGABQBIUAlARJAFEEhQCUBEkAUQSFAJQESQBRBIUAlARJAFEEhQCUBEkAUQVzAGsEiQBSBXMAawSJAFIFcwBrBIkAUgVzAGsEiQBSBa0AlARyAHoCRP+0Ahf/nQJE/9ECF/+7AkT/3QIX/8YCRAAYAgr//wJEAJ8GtQClBAsAfARyAC8CJf+uBQ4AlAQsAH0EUgCUAgoAjARSAJQCCgBZBFIAlAKgAIwEUgCUAuYAjAWtAJQEdAB6Ba0AlAR0AHoFrQCUBHQAegR0/6MFgwBlBIoATgWDAGUEigBOBYMAZQSKAE4FCQCUAtQAfQUJAJQC1ABSBQkAlALUADYE2ABLBB4ASQTYAEsEHgBJBNgASwQeAEkE2ABLBB4ASQTYAEsEHgBJBOAALQKqAAoE4AAtAqoACgTgAC0C0gAKBTwAgARzAHcFPACABHMAdwU8AIAEcwB3BTwAgARzAHcFPACABHMAdwU8AIAEcwB3BwsALwXwACME4wAIA+sADATjAAgE0wBQBAYAUQTTAFAEBgBRBNMAUAQGAFEHfv/8BsIASAWBAGkEhgBOBHr/pQR6/6UEPwAlBJoACASaAAgEmgAIBJoACASaAAgEmgAIBJoACASAAE8D4AB2A+AAdgPgAHYD4AB2Af7/qAH+AIYB/v+nAf7/nATcAHYEvQBOBL0ATgS9AE4EvQBOBL0ATgSIAGkEiABpBIgAaQSIAGkEPgAGBJoACASaAAgEmgAIBIAATwSAAE8EgABPBIAATwR6AGED4AB2A+AAdgPgAHYD4AB2A+AAdgSnAFYEpwBWBKcAVgSnAFYE3QB2Af7/kQH+/68B/v+6Af4AFwH+AH0D1gAmBF4AdgO3AHYDtwB2A7cAdgO3AHYE3AB2BNwAdgTcAHYEvQBOBL0ATgS9AE4EZAB1BGQAdQRkAHUENwA/BDcAPwQ3AD8ENwA/BD8AJQQ/ACUEPwAlBIgAaQSIAGkEiABpBIgAaQSIAGkEiABpBgkAJwQ+AAYEPgAGBCsAQQQrAEEEKwBBBU4AEQTp/0IGEf9LAqj/TgWX/7UFR/9BBW3/wgKl/4UFTgARBQ0AlASFAJQE0wBQBa0AlAJEAKUFDgCUBv8AlAWtAJQFgwBlBRsAlATgAC0E4wAIBQ0AJgJE/74E4wAIBIQAVgRlAGIEhgB9AqUAowRdAH8EmgCNBIoATgTBAJMD+AAWBFkANAKl/8MEXQB/BIoATgRdAH8GlABlBIUAlAR0AJkE2ABLAkQApQJE/74EcgAvBSgAmQUOAJQFCwAyBU4AEQUNAJQEdACZBIUAlAWmAJIG/wCUBa0AlAWDAGUFrgCZBRsAlAU5AGYE4AAtBQ0AJgRQAFYESQBRBJIAhASKAE4EfwB9BC0ATgPrAAwEBgAfBEkAUQNbAIMEHgBJAgoAfAIX/6gCAv+rBGwAjwPrAAwHCwAvBfAAIwcLAC8F8AAjBwsALwXwACME4wAIA+sADAFXAFICjgBgBDwAjAIl/6oBugA3Bv8AlAb4AHwFTgARBFAAVgSFAJQFpgCSBEkAUQSSAIQFsQBGBcwAUgUYABAEDf/yCHUATgluAGUE2wBJBBcATgU5AGYELQBOBOMACAQNAB4CRAClB6kAFQaHACACRAClBU4AEQRQAFYFTgARBFAAVgd+//wGwgBIBIUAlARJAFEFjQBVBDkAVwQ5AFcHqQAVBocAIATbAEkEFwBOBaYAkgSSAIQFpgCSBJIAhAWDAGUEigBOBXoAYASIAE0FegBgBIgATQVIAGMEOQBQBQsAMgPrAAwFCwAyA+sADAULADID6wAMBYUAkQRlAGAG8ACZBm8AjwSCAFAFTgARBFAAVgVOABEEUABWBU4AEQRQAFYFTgARBFD/nwVOABEEUABWBU4AEQRQAFYFTgARBFAAVgVOABEEUABWBU4AEQRQAFYFTgARBFAAVgVOABEEUABWBU4AEQRQAFYEhQCUBEkAUQSFAJQESQBRBIUAlARJAFEEhQCUBEkAUQSF/94ESf+UBIUAlARJAFEEhQCUBEkAUQSFAJQESQBRAkQApQIXAJACRACWAgoAeAWDAGUEigBOBYMAZQSKAE4FgwBlBIoATgWDACwEiv+qBYMAZQSKAE4FgwBlBIoATgWDAGUEigBOBZEAWwSdAE0FkQBbBJ0ATQWRAFsEnQBNBZEAWwSdAE0FkQBbBJ0ATQU8AIAEcwB3BTwAgARzAHcFowCABOYAdwWjAIAE5gB3BaMAgATmAHcFowCABOYAdwWjAIAE5gB3BOMACAPrAAwE4wAIA+sADATjAAgD6wAMBKAAUATgAC0D+gAjBYUAkQRlAGAEdACZA1sAgwYbAAoExP/LBHIAegUC/9cFAv/XBHT/9ANb/98FPP/zBET/yQTjAAgEDQAeBQ0AJgQGAB8EZQBiBGgAAQYqAHsEjABSBIwATgSMADcEjAB/BKAAhwS0AHsEoABdBLQAfAVzAGsEiQBSBa0AlAR0AHoFTgARBFAADgSFAE4ESQADAkT++wIX/uQFgwBlBIoAGQUJADUC1P9zBTwAdwRzABQE6/8MBQ0AlAR/AH0FOQCUBIIAUAU5AJQEggBQBa0AlARyAHoFDgCUBCwAfQUOAJQELAB9BFIAlAIKAHgG/wCUBvgAfAWtAJQEdAB6BYMAZQUbAJQEfwB9BQkAlALUAHEE2ABLBB4ASQTgAC0CqgAKBTwAgAUqABED+AAWBSoAEQP4ABYHCwAvBfAAIwTTAFAEBgBRBcn+bASaAAgEHP9jBRn/awI6/24Ex/+ZBHr/IATq/6sEmgAIBGAAdgPgAHYEKwBBBN0AdgH+AIYEXgB2BgUAdgTcAHYEvQBOBGsAdgQ/ACUEPgAGBFwAEwH+/5wEPgAGA+AAdgO8AHYENwA/Af4AhgH+/5wD1gAmBF4AdgRMAB8EmgAIBGAAdgO8AHYD4AB2BOIAdgYFAHYE3QB2BL0ATgTZAHYEawB2BIAATwQ/ACUEXAATBEYAQwTdAHYEgABPBD4ABgYAAA4E4gB2BEwAHwWmAE8F1ACGBkb/7AS9AE4ENwA/BgkAJwYJACcGCQAnBD4ABgVOABEEUABWBIUAlARJAFEEmgAIA+AAdgIXAHgE1QCyBNUAkwYMAGQE1QCyAAAAAgAAAAMAAAAUAAMAAQAAABQABAaSAAAA/ACAAAYAfAAAAAIADQB+AKAArACtAL8AxgDPAOYA7wD+AQ8BEQElAScBMAFTAV8BZwF+AX8BjwGSAaEBsAHwAf8CGwI3AlkCvALHAskC3QLzAwEDAwMJAw8DIwOKA4wDkgOhA7ADuQPJA84D0gPWBCUELwRFBE8EYgRvBHkEhgSfBKkEsQS6BM4E1wThBPUFAQUQBRMeAR4/HoUenh7xHvMe+R9NIAkgCyARIBUgHiAiICcgMCAzIDogPCBEIHAgjiCkIKogrCCxILogvSDBIQUhEyEWISIhJiEuIV4iAiIGIg8iEiIaIh4iKyJIImAiZSWgJcslz+4C9sP7BP7///3//wAAAAAAAgANACAAoAChAK0ArgDAAMcA0ADnAPAA/wEQARIBJgEoATEBVAFgAWgBfwGPAZIBoAGvAfAB+gIYAjcCWQK8AsYCyQLYAvMDAAMDAwkDDwMjA4QDjAOOA5MDowOxA7oDygPRA9YEAAQmBDAERgRQBGMEcAR6BIgEoASqBLIEuwTPBNgE4gT2BQIFER4AHj4egB6eHqAe8h70H00gACAKIBAgEyAXICAgJSAwIDIgOSA8IEQgcCB0IKMgpiCrILEguSC8IMEhBSETIRYhIiEmIS4hWyICIgYiDyIRIhoiHiIrIkgiYCJkJaAlyiXP7gH2w/sB/v///P//AAEAAP/2/+QB9P/CAej/wQAAAdsAAAHWAAAB0gAAAdAAAAHOAAABxgAAAcj/Fv8H/wX++P7rAgoAAAAA/mX+RAE//dj91/3J/bT9qP2n/aL9nf2KAAAAGgAZAAAAAP0KAAD/+vz+/PsAAPy6AAD8sgAA/KcAAPyhAAD8mQAA/JEAAP9EAAD/QQAA/F4AAOX+5b7lb+LT5ZrlA+WY5Znhc+F04XAAAOFt4WzhauFi48XhWuO94VHhJuEjAADhDQAA4QjhAeEA5GvgueCs4Krgn9+U4JTgaN/F3qzfud+437Hfrt+i34bfb99s34sAAN9bE9ILEgbWAt4B4gABAAAAAAAAAAAAAAAAAAAAAADsAAAA9gAAASAAAAE6AAABOgAAAToAAAF8AAAAAAAAAAAAAAAAAAABfAGGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAXQAAAAAAXwBmAAAAbAAAAAAAAAByAAAAhAAAAI4AAACWgAAAmoAAAKWAAACogAAAsYAAALWAAAC6gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC2AAAAAAAAAAAAAAAAAAAAAAAAAAAAsgAAALIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACngAAAAAAAAAAAAAAAAAAApsCnAKdAp4CnwKgAIEClwKrAqwCrQKuAq8CsACCAIMCsQKyArMCtAK1AIQAhQK2ArcCuAK5AroCuwCGAIcCxgLHAsgCyQLKAssAiACJAswCzQLOAs8C0ACKApYAiwCMApgAjQL/AwADAQMCAwMDBACOAwUDBgMHAwgDCQMKAwsDDACPAJADDQMOAw8DEAMRAxIDEwCRAJIDFAMVAxYDFwMYAxkAkwCUAygDKQMsAy0DLgMvApkCmgKhArwDRwNIA0kDSgMmAycDKgMrAK4ArwOiALADowOkA6UAsQCyA6wDrQOuALMDrwOwALQDsQOyALUDswC2A7QAtwO1A7YAuAO3ALkAugO4A7kDugO7A7wDvQO+A78AxAPBA8IAxQPAAMYAxwDIAMkAygDLAMwDwwDNAM4EAAPJANIDygDTA8sDzAPNA84A1ADVANYD0AQBA9EA1wPSANgD0wPUANkD1QDaANsA3APWA88A3QPXA9gD2QPaA9sD3APdAN4A3wPeA98A6gDrAOwA7QPgAO4A7wDwA+EA8QDyAPMA9APiAPUD4wPkAPYD5QD3A+YEAgPnAQID6AEDA+kD6gPrA+wBBAEFAQYD7QQDA+4BBwEIAQkEnQQEBAUBFwEYARkBGgQGBAcECQQIASgBKQEqASsEnAEsAS0BLgEvATAEngSfATEBMgEzATQECgQLATUBNgE3ATgEoAShBAwEDQSTBJQEDgQPBKIEowSbAUwBTQSZBJoEEAQRBBIBTgFPAVABUQFSAVMBVAFVBJUElgFWAVcBWAQdBBwEHgQfBCAEIQQiAVkBWgSXBJgENwQ4AVsBXAFdAV4EpASlAV8EOQSmAW8BcAGCAYMEqASnAbIEkgG4AdIFLQAAQEqZmJeWh4aFhIOCgYB/fn18e3p5eHd2dXRzcnFwb25tbGtqaWhnZmVkY2JhYF9eXVxbWllYV1ZVVFNRUE9OTUxLSklIR0YoHxAKCSwBsQsKQyNDZQotLACxCgtDI0MLLSwBsAZDsAdDZQotLLBPKyCwQFFYIUtSWEVEGyEhWRsjIbBAsAQlRbAEJUVhZIpjUlhFRBshIVlZLSwAsAdDsAZDCy0sS1MjS1FaWCBFimBEGyEhWS0sS1RYIEWKYEQbISFZLSxLUyNLUVpYOBshIVktLEtUWDgbISFZLSywAkNUWLBGKxshISEhWS0ssAJDVFiwRysbISEhWS0ssAJDVFiwSCsbISEhIVktLLACQ1RYsEkrGyEhIVktLCMgsABQiopksQADJVRYsEAbsQEDJVRYsAVDi1mwTytZI7BiKyMhI1hlWS0ssQgADCFUYEMtLLEMAAwhVGBDLSwBIEewAkMguBAAYrgQAGNXI7gBAGK4EABjV1pYsCBgZllILSyxAAIlsAIlsAIlU7gANSN4sAIlsAIlYLAgYyAgsAYlI2JQWIohsAFgIxsgILAGJSNiUlgjIbABYRuKISMhIFlZuP/BHGCwIGMjIS0ssQIAQrEjAYhRsUABiFNaWLgQALAgiFRYsgIBAkNgQlmxJAGIUVi4IACwQIhUWLICAgJDYEKxJAGIVFiyAiACQ2BCAEsBS1JYsgIIAkNgQlkbuEAAsICIVFiyAgQCQ2BCWbhAALCAY7gBAIhUWLICCAJDYEJZuUAAAQBjuAIAiFRYsgIQAkNgQlmxJgGIUVi5QAACAGO4BACIVFiyAkACQ2BCWblAAAQAY7gIAIhUWLICgAJDYEJZsSgBiFFYuUAACABjuBAAiFRYuQACAQCwAkNgQllZWVlZWVmxAAJDVFhACgVACEAJQAwCDQIbsQECQ1RYsgVACLoBAAAJAQCzDAENARuxgAJDUliyBUAIuAGAsQlAG7gBALACQ1JYsgVACLoBgAAJAUAbuAGAsAJDUliyBUAIuAIAsQlAG7IFQAi6AQAACQEAWVlZuEAAsICIVblAAAIAY7gEAIhVWlizDAANARuzDAANAVlZWUJCQkJCLSxFsQJOKyOwTysgsEBRWCFLUViwAiVFsQFOK2BZGyNLUViwAyVFIGSKY7BAU1ixAk4rYBshWRshWVlELSwgsABQIFgjZRsjWbEUFIpwRbBPKyOxYQYmYCuKWLAFQ4tZI1hlWSMQOi0ssAMlSWMjRmCwTysjsAQlsAQlSbADJWNWIGCwYmArsAMlIBBGikZgsCBjYTotLLAAFrECAyWxAQQlAT4APrEBAgYMsAojZUKwCyNCsQIDJbEBBCUBPwA/sQECBgywBiNlQrAHI0KwARaxAAJDVFhFI0UgGGmKYyNiICCwQFBYZxtmWWGwIGOwQCNhsAQjQhuxBABCISFZGAEtLCBFsQBOK0QtLEtRsUBPK1BbWCBFsQFOKyCKikQgsUAEJmFjYbEBTitEIRsjIYpFsQFOKyCKI0REWS0sS1GxQE8rUFtYRSCKsEBhY2AbIyFFWbEBTitELSwjRSCKRSNhIGSwQFGwBCUgsABTI7BAUVpasUBPK1RaWIoMZCNkI1NYsUBAimEgY2EbIGNZG4pZY7ECTitgRC0sAS0sAC0sBbELCkMjQ2UKLSyxCgtDI0MLAi0ssAIlY2awAiW4IABiYCNiLSywAiVjsCBgZrACJbggAGJgI2ItLLACJWNnsAIluCAAYmAjYi0ssAIlY2awIGCwAiW4IABiYCNiLSwjSrECTistLCNKsQFOKy0sI4pKI0VksAIlZLACJWFksANDUlghIGRZsQJOKyOwAFBYZVktLCOKSiNFZLACJWSwAiVhZLADQ1JYISBkWbEBTisjsABQWGVZLSwgsAMlSrECTiuKEDstLCCwAyVKsQFOK4oQOy0ssAMlsAMlirBnK4oQOy0ssAMlsAMlirBoK4oQOy0ssAMlRrADJUZgsAQlLrAEJbAEJbAEJiCwAFBYIbBqG7BsWSuwAyVGsAMlRmBhsIBiIIogECM6IyAQIzotLLADJUewAyVHYLAFJUewgGNhsAIlsAYlSWMjsAUlSrCAYyBYYhshWbAEJkZgikaKRmCwIGNhLSywBCawBCWwBCWwBCawbisgiiAQIzojIBAjOi0sIyCwAVRYIbACJbECTiuwgFAgYFkgYGAgsAFRWCEhGyCwBVFYISBmYbBAI2GxAAMlULADJbADJVBaWCCwAyVhilNYIbAAWRshWRuwB1RYIGZhZSMhGyEhsABZWVmxAk4rLSywAiWwBCVKsABTWLAAG4qKI4qwAVmwBCVGIGZhILAFJrAGJkmwBSawBSawcCsjYWWwIGAgZmGwIGFlLSywAiVGIIogsABQWCGxAk4rG0UjIVlhZbACJRA7LSywBCYguAIAYiC4AgBjiiNhILBdYCuwBSURihKKIDmKWLkAXRAAsAQmY1ZgKyMhIBAgRiCxAk4rI2EbIyEgiiAQSbECTitZOy0suQBdEACwCSVjVmArsAUlsAUlsAUmsG0rsV0HJWArsAUlsAUlsAUlsAUlsG8ruQBdEACwCCZjVmArILAAUliwUCuwBSWwBSWwByWwByWwBSWwcSuwAhc4sABSsAIlsAFSWliwBCWwBiVJsAMlsAUlSWAgsEBSWCEbsABSWCCwAlRYsAQlsAQlsAclsAclSbACFzgbsAQlsAQlsAQlsAYlSbACFzhZWVlZWSEhISEhLSy5AF0QALALJWNWYCuwByWwByWwBiWwBiWwDCWwDCWwCSWwCCWwbiuwBBc4sAclsAclsAcmsG0rsAQlsAQlsAQmsG0rsFArsAYlsAYlsAMlsHErsAUlsAUlsAMlsAIXOCCwBiWwBiWwBSWwcStgsAYlsAYlsAQlZbACFziwAiWwAiVgILBAU1ghsEBhI7BAYSMbuP/AUFiwQGAjsEBgI1lZsAglsAglsAQmsAIXOLAFJbAFJYqwAhc4ILAAUliwBiWwCCVJsAMlsAUlSWAgsEBSWCEbsABSWLAGJbAGJbAGJbAGJbALJbALJUmwBBc4sAYlsAYlsAYlsAYlsAolsAolsAclsHErsAQXOLAEJbAEJbAFJbAHJbAFJbBxK7ACFzgbsAQlsAQluP/AsAIXOFlZWSEhISEhISEhLSywBCWwAyWHsAMlsAMliiCwAFBYIbBlG7BoWStksAQlsAQlBrAEJbAEJUkgIGOwAyUgY1GxAAMlVFtYISEjIQcbIGOwAiUgY2EgsFMrimOwBSWwBSWHsAQlsAQmSrAAUFhlWbAEJiABRiMARrAFJiABRiMARrAAFgCwACNIAbAAI0gAILABI0iwAiNIASCwASNIsAIjSCOyAgABCCM4sgIAAQkjOLECAQewARZZLSwjEA0MimMjimNgZLlAAAQAY1BYsAA4GzxZLSywBiWwCSWwCSWwByawdisjsABUWAUbBFmwBCWwBiawdyuwBSWwBSawBSWwBSawdiuwAFRYBRsEWbB3Ky0ssAclsAolsAolsAgmsHYrirAAVFgFGwRZsAUlsAcmsHcrsAYlsAYmsAYlsAYmsHYrCLB3Ky0ssAclsAolsAolsAgmsHYriooIsAQlsAYmsHcrsAUlsAUmsAUlsAUmsHYrsABUWAUbBFmwdystLLAIJbALJbALJbAJJrB2K7AEJrAEJgiwBSWwByawdyuwBiWwBiawBiWwBiawdisIsHcrLSwDsAMlsAMlSrAEJbADJUoCsAUlsAUmSrAFJrAFJkqwBCZjiopjYS0ssV0OJWArsAwmEbAFJhKwCiU5sAclObAKJbAKJbAJJbB8K7AAULALJbAIJbAKJbB8K7AAUFRYsAclsAslh7AEJbAEJQuwCiUQsAklwbACJbACJQuwByUQsAYlwRuwByWwCyWwCyW4//+wdiuwBCWwBCULsAclsAolsHcrsAolsAglsAgluP//sHYrsAIlsAIlC7AKJbAHJbB3K1mwCiVGsAolRmCwCCVGsAglRmCwBiWwBiULsAwlsAwlsAwmILAAUFghsGobsGxZK7AEJbAEJQuwCSWwCSWwCSYgsABQWCGwahuwbFkrI7AKJUawCiVGYGGwIGMjsAglRrAIJUZgYbAgY7EBDCVUWAQbBVmwCiYgELADJTqwBiawBiYLsAcmIBCKOrEBByZUWAQbBVmwBSYgELACJTqKigsjIBAjOi0sI7ABVFi5AABAABu4QACwAFmKsAFUWLkAAEAAG7hAALAAWbB9Ky0siooIDYqwAVRYuQAAQAAbuEAAsABZsH0rLSwIsAFUWLkAAEAAG7hAALAAWQ2wfSstLLAEJrAEJggNsAQmsAQmCA2wfSstLCABRiMARrAKQ7ALQ4pjI2JhLSywCSuwBiUusAUlfcWwBiWwBSWwBCUgsABQWCGwahuwbFkrsAUlsAQlsAMlILAAUFghsGobsGxZKxiwCCWwByWwBiWwCiWwbyuwBiWwBSWwBCYgsABQWCGwZhuwaFkrsAUlsAQlsAQmILAAUFghsGYbsGhZK1RYfbAEJRCwAyXFsAIlELABJcWwBSYhsAUmIRuwBiawBCWwAyWwCCawbytZsQACQ1RYfbACJbCCK7AFJbCCKyAgaWGwBEMBI2GwYGAgaWGwIGEgsAgmsAgmirACFziKimEgaWFhsAIXOBshISEhWRgtLEtSsQECQ1NaWCMQIAE8ADwbISFZLSwjsAIlsAIlU1ggsAQlWDwbOVmwAWC4/+kcWSEhIS0ssAIlR7ACJUdUiiAgEBGwAWCKIBKwAWGwhSstLLAEJUewAiVHVCMgErABYSMgsAYmICAQEbABYLAGJrCFK4qKsIUrLSywAkNUWAwCiktTsAQmS1FaWAo4GwohIVkbISEhIVktLLCYK1gMAopLU7AEJktRWlgKOBsKISFZGyEhISFZLSwgsAJDVLABI7gAaCN4IbEAAkO4AF4jeSGwAkMjsCAgXFghISGwALgATRxZioogiiCKI7gQAGNWWLgQAGNWWCEhIbABuAAwHFkbIVmwgGIgXFghISGwALgAHRxZI7CAYiBcWCEhIbAAuAAMHFmKsAFhuP+rHCMhLSwgsAJDVLABI7gAgSN4IbEAAkO4AHcjeSGxAAJDirAgIFxYISEhuABnHFmKiiCKIIojuBAAY1ZYuBAAY1ZYsAQmsAFbsAQmsAQmsAQmGyEhISG4ADiwACMcWRshWbAEJiOwgGIgXFiKXIpaIyEjIbgAHhxZirCAYiBcWCEhIyG4AA4cWbAEJrABYbj/kxwjIS0AAED/fjR9VXw+/x97O/8fej3/H3k7QB94PP8fdzw9H3Y1Bx91Ov8fdDpnH3M5Tx9yOf8fcTb/H3A4zR9vOP8fbjdeH203zR9sN/8fazctH2o3GB9pNP8faDL/H2cyzR9mM/8fZTH/H2Qw/x9jMKsfYjBnH2Eu/x9gLoAfXy//H14vkx9dLf8fXCz/H1sr/x9aKs0fWSr/H1gqDR9XKf8fVij/H1UnJB9UJy0fUyVeH1Il/x9RJasfUCb/H08mgB9OJP8fTSMrH0wjqx9LI/8fSiNWH0kjKx9IIv8fRyD/H0Ygch9FIf8fRCFyH0Mf/x9CHpMfQR7/H0Ad/x8/HP8fPTuTQOofPDs0Hzo1Dh85NnIfODZPHzc2Ih82NZMfMzJAHzEwch8vLkofKypAHycZBB8mJSgfJTMbGVwkGhIfIwUaGVwiGf8fISA9HyA4GBZcHxgtHx4X/x8dFv8fHBYHHxszGRxbGDQWHFsaMxkcWxc0FhxbFRk+FqZaEzESVRExEFUSWRBZDTQMVQU0BFUMWQRZHwRfBAIPBH8E7wQDD14OVQs0ClUHNAZVATEAVQ5ZClkGWX8GAS8GTwZvBgM/Bl8GfwYDAFkvAAEvAG8A7wADCTQIVQM0AlUIWQJZHwJfAgIPAn8C7wIDA0BABQG4AZCwVCtLuAf/UkuwCVBbsAGIsCVTsAGIsEBRWrAGiLAAVVpbWLEBAY5ZhY2NAB1CS7CQU1iyAwAAHUJZsQICQ1FYsQQDjllzdAArACsrK3N0ACtzdHUAKwArACsrKysrc3QAKwArKysAKwArKysBKwErASsBKwErASsrACsrASsrASsAKwArASsrKysrASsrACsrKysrKysBKysAKysrKysrKwErACsrKysrKysrKysrKysBKysAKysrKysrKysrKwErKysrKysrACsrKysrKysrKysrKysrKysrKysrKxgAAAYAABUFsAAUBbAAFAQ6ABQAAP/sAAD/7AAA/+z+YP/1BbAAFQAA/+sAAAC9AMAAnQCdALoAlwCXACcAwACdAIYAvACrALoAmgDTALMAmQHgAJYAugCaAKkBCwCCAK4AoACMAJUAuQCpABcAkwCaAHsAiwChAN4AoACMAJ0AtgAnAMAAnQCkAIYAogCrALYAvwC6AIIAjgCaAKIAsgDTAJEAmQCtALMAvgHJAf0AlgC6AEcAmACdAKkBCwCCAJkAnwCpALAAgQCFAIsAlACpALUAugAXAFAAYwB4AH0AgwCLAJAAmACiAK4A1ADeASYAewCJAJMAnQClALQEjQAQAAAAAAAyADIAMgAyADIAWgB5AK8BJAGlAhkCLgJeAo4CuwLYAvIDAwMeAzIDfwOYA9cEPgRqBLcFEQUuBZ0F9wYDBg8GNAZPBnQGxQdvB6cIBghKCIgIuAjhCTAJWAlsCZcJygnoChsKPgqKCr0LFQtaC7kL1wwFDC0MbwyeDMMM8A0JDR0NNg1bDWsNfw3nDjoOgA7TDyAPTw+3D+8QFRBOEIEQlRDxESsRcRHEEhgSTBKjEtMTChMwE3ITnxPbFAcUTRRfFKYU5RUJFWMVrhYPFlYWcBcCFy8Xpxf9GAkYJhi/GNAZAxkoGV8ZvRnRGhEaMBpKGnQaixrJGtUa5hr3GwgbWBulG8McHBxVHLIdUB2xHegePB6QHuwfHR8xH2MfjB+rH+cgNCCfISghTiGaIekiSiKhIuAjKyNRI5sjuyPaI+IkBCQfJE8keiS2JNQlACUUJSklMiVdJXollCWnJeIl6iYBJjEmiSaxJtgm9ScpJ3wnuSgYKIIo5CkRKXsp4SoyKmwqxyrtK0ArsCvpLDcsgizVLQUtPS2QLdEuOC6XLu0vXi+nL/cwUzCbMNow/jFBMZMx4DJHMmoyojLgMzIzWzORM7Yz5zQkNGM0mDToNUo1iTX4Nlw2cza4Nwc3azeON8A3+DgnOE84dTiROSU5TTmBOaY51zoVOlM6iDrWOzQ7dDvPPB08eDzBPQE9Jj17PdE+ED5pPsM+/z83P4o/2UA8QJ1BE0GKQghChELrQz1Dc0OrRBBEbkUSRbNGG0aERshHCUc5R1dHgkeXR61IRUiWSLJIzkkJSUxJsEnSSfRKL0pqSn1KkEqcSq9K7kssS2ZLoEuzS8ZL90woTGdMsE0aTYJNlU2oTdpODE4fTjJOdk64Tu5PTk+sT/VQO1BOUGFQmFDRUORQ91EKUR1Ra1G2UgFSEFIgUixSOFJqUsBTNVOqVB9UjFT3VVNVslX+Vk1WmVbjVyRXZVfNV9lX5VhHWG9Yb1hvWG9Yb1hvWG9Yb1hvWG9Yb1hvWG9Yb1h3WH9YkFihWLxY1ljxWQxZJlkyWT5Za1mKWbRZ0FncWexaBlq6Wt1a/VsUWx1bJlsvWzhbQVtKW1NbcluDW51bx1vyXCdcMFw5XEJcS1xUXF1cZlxvXHhcgVyKXJNcnFzDXOpdPF1zXctd114vXnVex18RX2JfoV/dYBhglmDhYUNhfGHEYdph62IBYhdifGKWYsli2mMFY5NjzWQrZFhkiWS7ZO9k/GUYZTJlPmV1ZbFmDWZwZstncWdxaGdorWjiaQZpQ2mVagZqIGpwarNq22s9a3ZrjmvUbABsMWxcbJxsv2zrbQdtY22jbfhuKm5wbpBuwG7bbwtvM29Fb2xvtG/dcE9wnHDZcPRxI3FzcZZxvHHfchVyYXKhcwBzR3OTc+h0LHRodJd00XUXdWh1zHX3dil2YHabdsx2/ncsd2l3oXetd914KniFeM149XlQeY15y3oFem16eXqyeut7Kntbe7F7+nxEfKN8+n1Lfa596n4+fmV+on7tfwZ/bH+3f8iAAoAxgNCBKoGAgbOB5YIVgkmChILGgyaDV4Nzg56D2oP+hCSEYYSmhM+E+oVHhVCFWYVihWuFdIV9hYaFzYYdhluGp4cChx+HXYeeh8aID4gqiHqIi4j7iVaJeomCiYqJkomaiaKJqomyibqJwonKidKJ2oniifSJ/IpdiqKKv4sSi1iLq4wTjFmMrI0AjUmNsI3/jgeOc46djuqPHY9yj6GP4I/gj+iQMZB6kLqQ35EbkS6RQZFUkWeRe5GPkaWRuJHLkd6R8ZIFkhiSK5I+klKSZZJ4kouSnpKxksWS2JLrkv6TEpMlkziTS5Ndk2+TgpOWk6yTv5PSk+WT95QKlB2UL5RClFaUaJR7lI6UoJSylMWU2JTrlP2VEJUjlTaVSZVblW6VgJXXll+WcpaFlpiWqpa9ltCW45b1lwiXG5cul0CXU5dll3iXi5fgmE6YYZhzmIaYmJirmL2Y0JjjmPeZCpkdmTCZQ5lWmWmZfJmPmaKZtJnGmdmZ5ZnxmgSaF5ormj+aUpplmnmajZqgmrOav5rLmt6a8ZsFmxmbLJs+m1GbZJt2m4mbnJuwm8Sb15vqm/6cEpwlnDecSpxdnHCcgpyVnKicvJzQnOOc9Z0JnR2dMJ1DnVadap19nY+dop20nced2p3ungKeFp4qnnqe1Z7onvufDp8gnzSfR59an22fgJ+Tn6WfuJ/Ln96f8Z/9oAmgFKAnoDqgTKBeoHKghqCSoJ6gsaDEoNag6aD8oQ6hIaE1oUihW6FuoYChkqGmobmhzKHeofGiBKIWoimie6KOoqCis6LFotei6aL7ow6jYKNyo4Sjl6Oqo76j0KPjo/akCaQUpCakOaRFpFeka6R3pIOklqSipLWkx6TapO6lAaUNpR+lMqVEpVClYqV2pYillKWmpbily6XfpfOmQqZVpmemeqaNpqCmsqbFptmm5ab5pw2nIKc0p0mnUadZp2Gnaadxp3mngaeJp5Gnmaehp6mnsae5p82n4af0qAeoGqgsqECoSKhQqFioYKhoqHyoj6iiqLWoyKjcqO+pTKlUqWipcKl4qYupnqmmqa6ptqm+qdGp2anhqemp8an5qgGqCaoRqhmqIao0qjyqRKqHqo+ql6qqqr2qxarNquGq6ar8qw6rIas0q0erWqtuq4Krlaunq6+rt6vDq9ar3qvxrASsGawurEGsVKxnrHqsgqyKrJ6ssqy+rMqs3azwrQOtFq0erSatLq1BrVStXK1vrYGtla2orbCtuK3Lrd2t8a35rgyuIK40rkiuW65uroCulK6orryuz67Xrt+u868GrxqvLa9Ar1KvZq95r42voa+1r8iv3K/wr/iwDLAgsDOwRrBasG2wgbCUsKiwu7DPsOKw/7EbsS+xQrFWsWmxfbGQsaSxt7HUsfCyBLIYsiuyPrJRsmOyd7KKsp6ysbLFstiy7LL/sxyzOLNLs16zcrOGs5qzrrPBs9Sz6LP7tA+0IrQ2tEm0XbRwtI20qbS8tM+04rT1tQi1G7UutUC1VLVotXy1kLWjtba1ybXcte+2ArYVtii2O7ZNtmG2dbaJtp22sLbDtta26LcFtxi3K7c+t1G3ZLd3t4q3nbelt+K4HrhAuGK4objiuRG5RLl8ubK5urnOuda53rnmue659rn+uga6DroWuim6PLpPumK6drqKup66srrGutq67rsCuxa7Krs+u1K7Xrtyu4a7mruuu8K71rvqu/68EbwkvDi8TLxgvHS8iLycvLC8xLzYvOu8/r0SvSa9Or1OvWK9dr2KvZ29r73Dvde9673/vhO+J747vke+U75fvmu+d76Dvo++l76fvqe+r763vr++x77Pvte+377nvu++977/vxO/Jr85v0y/VL9cv3C/eL+Lv52/pb+tv7W/vb/Qv9i/4L/ov/C/+MAAwAjAEMCBwLLA/sEGwRLBJcE3wT/BS8FewXHBfcGQwaPBt8HDwdbB6cH8wg/CG8InwjvCW8JswsfDAQAAAAYAZAAAAygFsAADAAcACwAPABMAFwAAQRUhNTMRIxEhESMRExUhNQEBIwERATMBAwn9dhs2AsQ2F/12Aor9rzoCUf2vOgJRBbA2NvpQBbD6UAWw+oY2NgVc+owFdPqMBXT6jAACAIz/8gGgBbAAAwAPABNACQICBw0LcgACcgArK93OLzAxQQMjAwM0NjMyFhUUBiMiJgGSGM4ZB0lBQEpKQEFJBbD7/QQD+sI3S0s3NUtLAAIAYAP4AjoGAAAFAAsADLMJAwsFAC8zzTIwMUEVAyMRNSEVAyMRNQEOI4sB2iOLBgCJ/oEBdJSJ/oEBfIwABABWAAAEsgWwAAMABwALAA8AI0ARBAAFDQ4OAAoJCQACAnIAEnIAKysROS8zETkvMzIRMzAxcwEzATMBMwEBITUhAyE1IfQBDKT+9OIBDKT+9AGU+/AEEEv77wQRBbD6UAWw+lADdZv9ipsAAwBk/ywEJwaZAAMABwA9ADZAHAQHOjoIKxAjBBQvNTUGLw1yAQIfHxQaGgMUBXIAK80zLxEzEjk5K80zLxESFzkzEjk5MDFBESMRExEjEQE0JiYnLgI1NDY2MzIeAhUjNC4CIyIGBhUUFhYXHgIVFAYGIyIuAjUzFB4CMzI2NgKxmoeZATAvalmAv2lxyodop3Y/8B04TzJHXCssa16BvWd31Y1Zr45U8ipIWS1LZzUGmf7VASv5n/70AQwBQzpXRx8tcad9e7RiPnivcUBlRyY1XDs5VkUjLnGlfYG0XS9ss4JOaDwaM10ABQBk/+sFigXFABEAIwA1AEcASwAjQBFJMksFO0QpMhcOIAUFcjINcgArKzLEMhDEMjMRMxEzMDFTNTQ2NjMyFhYVFRQGBiMiJiY3FRQWFjMyNjY1NTQmJiMiBgYBNTQ2NjMyFhYVFRQGBiMiJiY3FRQWFjMyNjY1NTQmJiMiBgYTAScBZEiKYWSJSEeJY2KLSKcfQC8wPR4fPjAuPx8CF0mKYWSJR0eIY2KLSaghQC0zPhsfPzAvPh/I/Tl7AscES01TiFJSiFNNUYhSUoieTShILCxIKE0pSSwsSfxWTlKIUlKIUk5SiFJSiKBOKEgtLUcpTilILCxIA1L7jkcEcgAAAQBV/+wFEAXEAEIAJEAUIxIADyIBBhowMCsRETsTcgcaA3IAKzIrMi8yMi8RFzkwMUE3NjY1NCYjIgYGFRQWFhcBIQEuAjU0NjYzMhYWFRQGBgcFDgIVFBYWMzI+AjUzFAYGBwYGBwYGIyImJjU0NjYBdfs/NlBJM0YjLlAyArD+6f3OSXA+Xqxzb6FXMlg6/s81MxA3a01TnHxJ0ClZSAcRCFbVeJHUc0qBAxipKlE9NFgvTS8tX2c7/NQClViTi0pypFlZkldFcl4q3itPQhlAaD1LisB1ar6iQAcVB09Narp4WYd1AAEAUgP+AQkGAAAFAAixAwUAL8YwMUEVAyMTNQEJGp0BBgCB/n8BcZEAAAEAgf4xAp4GXQAXAAixBhMALy8wMVM1NBISNjcXDgICFRUUEhYWFwcmJgICgV2Wq08wOnNfOTlfczowT6uWXQI/EdYBXQEHrSaKK5jd/tm6Fbr+2d6bLoQnrQEHAV0AAAEAJ/4xAk0GXQAXAAixEwYALy8wMUEVFAICBgcnPgISNTU0AiYmJzcWFhISAk1fl69QMTpzXzk7YnI2MVCvl18CUBHT/qT++LAnhCyZ4QEouhW6ASnfmiuEJrD+9/6kAAEAHAJQA3kFsQAOABRACg0BBwQEDgwGAnIAK8QyFzkwMVMTJTcFAzMDJRcFEwcDA4DS/so1ATQOrhABLzX+xM2NubYCuwETWqR2AVv+nnanW/7zZgEi/uYAAAIAQgCSBCgEtgADAAcAELUHBwMDBgIAL8YzEMYvMDFBFSE1AREjEQQo/BoCaOkDHtnZAZj73AQkAAABACL+uAFeAOgACgAIsQQAAC/NMDFlBxQGByc+AjU1AV4BZlSBHC4c6Kxm2EZLLVxoP7UAAQBQAg4CYQLOAAMACLEDAgAvMzAxQRUhNQJh/e8CzsDAAAEAhv/0AaAA/QALAAqzAwkLcgArMjAxdzQ2MzIWFRQGIyImhkxBQktLQkFMeDhNTTg4TEwAAAEAAf+DAvUFsAADAAmyAAIBAC8/MDFBASMBAvX9yb0COAWw+dMGLQACAGj/7AQjBcQAFwAvABNACSsGHxIFcgYNcgArKzIRMzAxQRUUDgIjIi4DNTU0PgIzMh4DAxE0LgMjIg4CFREUHgMzMj4CBCNDfq9sVpN2Uy1Efq9sV5N1UyzxFCc6Si44WDwfFCg5Sy05WDweA1Luq/GWRixeldCJ7qztlUQrXJPP/mcBNFeFXTsbK16Zbf7MWIZfPRwsYZwAAQCqAAADAAW1AAYADLUGBHIBDHIAKyswMUERIxEFNSUDAPH+mwI5BbX6SwSXecfQAAABAFIAAAQ+BcQAHwAZQAwQEAwVBXIDHx8CDHIAKzIRMysyMi8wMWUVITUBPgI1NCYmIyIGBhUjNDY2MzIWFhUUDgIHAQQ+/DAB2k5aJTNiRlFuOPF03JuSzGssUW5C/sXAwKUCBViAZzFFaT1Ge09/031itHtEhoWFRP6lAAACAE7/7AQaBcQAHAA7ACpAFhscHh8EAAAdHRIzLy8pDXINDQkSBXIAKzIyLysyLzIROS8zEhc5MDFBMzI2NjU0JiYjIgYGFSM0NjYzMhYWFRQOAiMjFTUzMh4CFRQOAiMiLgI1MxQWFjMyNjY1NCYmIwGJkFRvNjFjTEBnPPJ604SN03Y6cqpwtbWAtXI1SYazaV6siE/xPW9ITG47QnpTA0U6ZkJFYzYzXUB0tGdduIg+gGlBNoQ8aYZLZp9uODRnm2ZBYzg2aktVajMAAAIANwAABFkFsAAHAAsAHUAOAwcHBgICBQkMcgsFBHIAKzIrEjkvOTMSOTAxQRUhJwEzAwEBESMRBFn75ggCdMHR/pcCcfECB8CRA9j+mv29A6n6UAWwAAABAH//7AQ5BbAAKQAdQA4nCQkCHRkZEw1yBQIEcgArMisyLzIROS8zMDFBJxMhFSEDNjYzMh4CFRQOAiMiLgInMx4CMzI+AjU0LgIjIgYBa8BPAxH9tygieE1no3I8O3azelunhFAG7Ak9ZkM9WDsdIUFiQFZbAqUvAtzM/psUJ0N/tXFlsIZLNWmbZUdjNCtRbkNAak4rMgAAAQBz/+wEOQW5ADYAG0ANDiwYIiIsAwAEciwNcgArKzIROS8zETMwMUEzFSMiDgIVFRQeAjMyPgI1NC4CIyIGBgcnPgMzMh4CFRQOAiMiLgI1NTQSNiQDRh4Rgbt4OyZFWjQ2WD4gHzxZOkh1RwNcCENukVdqnGczQHuvb3W3f0JUrwESBbnFUIy7aeVXhVkuLVBuQT5tUy9EbT0eXZRoN1CJr19ptYhMWp7Oc2SmASfigQAAAQBEAAAENQWwAAYAE0AJAQUFBgRyAwxyACsrMhEzMDFBFQEjASE1BDX9uv4CRf0OBbCE+tQE8MAAAAQAZ//sBCYFxAAQACAAMABAACFAEA09PSUtFRUENS0Fch0EDXIAKzIrMhI5LxI5MxI5MDFBFAYGIyImJjU0PgIzMhYWBzQmJiMiBgYVFBYWMzI2NhMUBgYjIiYmNTQ2NjMyFhYHNCYmIyIGBhUUFhYzMjY2BCZ+2YiI2n5Gga9oitp98jxsR0hqOzpsSUlqOtFzyoGCy3NzyoKCynPxM1w/P1wyMl0/P1wyAY2Iul9fuohak2s6ZrRsSW48PG5JSms4OGsC4m2qYWGqbYKzXl6zikFjODZiRENjODhjAAEAXf/3BBUFxAA4ABtADQA4FiEhOAwrBXI4DHIAKysyETkvMxEzMDFlMzI+AjU1NC4CIyIOAhUUHgIzMj4CNxcUDgIjIi4CNTQ+AjMyHgIVFRQOAyMjATAUirluMCVDVzI3VzsfHTpYOzheRigCXD9vk1Zon2k0QHqvb3ayej4uZ6fxoha+SYKwZ/tZh1suMVVxQDxvVjIrSlwwHEyTeUhPiLBhabiNT1yi1ntVge/LmVUA//8Af//0AZoEUQQmABL5AAAHABL/+gNU//8AM/64AYcEUQQnABL/5wNUAAYAEBEAAAIAPgCnA4kETAAEAAkAFkAMAQMHBgAECAUIAgkCAC8vEhc5MDFTBRUBNSUBBzUB9AKV/LUDS/1rtgNLApH97QF0naj+/yOdAXMAAgCPAWQD8wPSAAMABwAOtQYHEgMCEAA/Mz8zMDFBFSE1ARUhNQPz/JwDZPycA9LGxv5YxsYAAgB+AKgD3gRNAAQACQAVQAsFCAQABgMBBwIJAgAvLxIXOTAxQSU1ARUFATcVAQMf/V8DYPygAqO9/KACafvp/o2eqwEAKJ3+jAACADv/9AOXBcQAIAAsABtADQEBJCQqC3IREQ0WA3IAKzIyLysyETMvMDFBIz4CNz4CNTQmJiMiBgYHIz4CMzIWFhUUBgYHBgYDNDYzMhYVFAYjIiYCP98BHkc7LkosKlE8Mlg2AvECdMR5hr5lRnBBOCj0SkBASkpAQEoBrV1/aDosT1k6P1guJ1FCfqxWW616WI97PTN3/nw2S0s2NktLAAACAFv+OwbWBY8AQQBoACdAEhIFBUdSE3JhZGQLXV0dHTwpMAAvMy8zETMvMzMRMysyMhEzMDFBDgMjIi4CNxMzAwYeAjMyPgI3Ni4DIyIOAwcGHgMzMjY3FwYGIyIkJiYCNzYSNjYkMzIeAhIBBh4CMzI+AjcXDgMjIi4CNz4EMzIWFwcmJiMiDgIGzwQyZZ5vQ2hFHgczrzIGESQuFzZWPSMDByhfl9KHfNKmd0MGBy1mm819WLU+JkbSXZv+/8WCPgcHVpfRAQaanPy/fjr8AAcNJTwoGTk4MhFMF0ZYZjdJcUgeCQo5VWx9QnGAOV4dXUA5XUYvAghhwJ5eL1h9TQI3/ck9TioQPW2QVIztuoFETI/H942U9LyBQighhS0sUJvgASKvpAEh7KtcUpze/un+/URqSCYZOF1FV053TylAdaNlZ7CKYTNAK3gbMDRpmgAAAwARAAAFPwWwAAQACQANAClAFAQHBwoNDQYACwwMAggDAnIFAghyACsyKzIROS8zOTkzETMyETMwMUEBIQEzAQEnMwEBFSE1Asv+Tf75AiSoAVr+TBOpAib+4/zoBO77EgWw+lAE7sL6UAIcx8cAAAIAlAAABKUFsAAZADAAKUAUGSkmAicnASYmDgwPAnIcGxsOCHIAKzIRMysyETkvMzMRMxI5OTAxQSEnITI2NjU0JiYjIxEjESEyHgIVFAYGBwMhNyEyNjY1NCYmIyE3IRceAhUUBgYCtv6NAgFEUnM8OHNZ8/sB7ni9hUVWqH1b/klxAUZVcjkybFf+5gIBbzl4m0x54gKStzFdQklcKvsYBbAuYZRmWpVeCf0vxzllREdpObdFBGKcWou8YQABAGb/7ATrBcQAJwAVQAoZFRADciQABQlyACvMMyvMMzAxQTMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4CMzI2NgPw+gyI9rCH2JpRU5zbia7whQ/6CkOCaVaAVisnUX5Ya4VFAdqP34Bhs/6deZ3+tWCA4pJehkdAfLV0e26zgEZEgwAAAgCUAAAE0gWwABoAHgAbQA0CAQEdDg8PHgJyHQhyACsrMhEzETMRMzAxYSE3ITI2NjU1NC4CIyE1ITIeAhUVFA4CAREjEQI7/skCATWHt101Z5Vh/roBRpHwr15esPP+vvvHdtyYT3a2fEDIYbb+nU2d/rVhBbD6UAWwAAQAlAAABE0FsAADAAcACwAPAB1ADgsKCgYPDgcCcgMCBghyACsyMisyMhE5LzMwMWUVITUTESMRARUhNQEVITUETfz7R/sDVP1gAwD9AMfHxwTp+lAFsP2gxMQCYMjIAAMAlAAABDQFsAADAAcACwAbQA0HBgYCCgsLAwJyAghyACsrMhEzETkvMzAxQREjEQEVITUBFSE1AY/7A039bgLl/RsFsPpQBbD9g8fHAn3IyAABAGv/7ATyBcQAKwAbQA0rKioFGRUQA3IkBQlyACsyK8wzEjkvMzAxQREOAiMiJiYCNTU0EjY2MzIWFhcjLgIjIg4CFRUUHgIzMjY2NxEhNQTyH4PYoYnkpVpTnN2Ms+uAEfYMRX9lV4RXLDNhjFhWbkES/tEC6P3UKWFGXbQBA6ZlpQEDtF130odMeEVCgLh2Z3i6gEEdKRMBIbsAAAMAlAAABRcFsAADAAcACwAbQA0JBggDAgIGBwJyBghyACsrETkvMzIRMzAxQRUhNRMRIxEhESMRBFb8+z77BIP6A1DHxwJg+lAFsPpQBbAAAQClAAABoAWwAAMADLUAAnIBCHIAKyswMUERIxEBoPsFsPpQBbAAAAEAL//sA+UFsAATABNACRAMDAcJcgICcgArKzIvMjAxQREzERQGBiMiJiY1MxQWFjMyNjYC6/p81oiL13r8N2VEQWU6AbUD+/wFkcxsXsKVVmkvO3MAAwCUAAAFFgWwAAMACQANABxAEAYHCwUMCAYCBAMCcgoCCHIAKzIrMhIXOTAxQREjESEBAScTARMBNwEBj/sEZv2y/rAs8AGoJP4hrQJcBbD6UAWw/UP+nPkBKAIA+lACsqv8owAAAgCUAAAEJAWwAAMABwAVQAoDAgIGBwJyBghyACsrETMRMzAxZRUhNRMRIxEEJP0lRvvHx8cE6fpQBbAAAwCUAAAGagWwAAYACwAQABtADQIHDgULCHIMBAAHAnIAKzIyMisyMhE5MDFTMwEBMwEjATMTESMBMxEjEfrgAaUBpOD91LL9b9Ul+gUA1vsFsPudBGP6UAWw/DT+HAWw+lAB5AAAAQCUAAAFFwWwAAkAF0ALAwgFCQcCcgIFCHIAKzIrMhI5OTAxQREjAREjETMBEQUX+/1z+/sCjwWw+lAEE/vtBbD76wQVAAIAZf/sBR0FxAAVACsAE0AJJwYcEQNyBglyACsrMhEzMDFBFRQCBgYjIiYmAjU1NBI2NjMyFhYSBzU0LgIjIg4CFRUUHgIzMj4CBR1Wn96Hht2iWVih3YaH3qBX+y9bhFNTglswMF2CU1SCWi8DAFCl/vq4YWG4AQalUKUBBblhYbn++/VSert/QUF/u3pSeryBQUGBvAAAAQCUAAAEzwWwABcAF0ALAgEBDgwPAnIOCHIAKysyETkvMzAxQSE1ITI2NjU0JiYjIREjESEyFhYVFAYGAr3+hQF7Y3o5OXpj/tL7Aimp7Xx87QIfx0BxSUV5SvsYBbB30YaNymwAAwBg/wMFGQXEAAMAGQAvABlADCAVA3IAKysDCglyAgAvKzIyETMrMjAxZQEHAQEVFAIGBiMiJiYCNTU0EjY2MzIWFhIHNTQuAiMiDgIVFRQeAjMyPgIDlwF/o/6IAh5WoN6Hht2iWVih3YaH36BX/C9bg1RSglwwMF2DUlSCWi/C/tCPAS0C0FCl/vq4YWG4AQalUKUBBblhYbn++/VSert/QUF/u3pSeryBQUGBvAACAJQAAATfBbAAGAAdACNAEhsaCQMMDAsLABwZGAhyFgACcgArMisyMhI5LzMSFzkwMVMhMhYWFRQGBgcHISchMjY2NTQmJiMhESMhASUBFZQCA6bqfVCSZUz+MQIBW1p4PTt6Xv74+wM//qoBBwFbBbBkw49tpnEfJcdAb0ZMcT37GAKOAf1+DQABAEv/7ASOBcQAOQAfQA8KJg82MTErCXIYFBQPA3IAKzIvMisyLzIROTkwMUE0LgInLgM1ND4CMzIWFhUjNCYmIyIGBhUUHgIXHgMVFA4CIyIuAjUzFB4CMzI2NgOSG0R7X2ivgkhLi75zout/+T17Xll2OiZOdlB5tHg8Som/dWnLpmL7MVh1Q1h3PAF3LUY6Nx0gT2mJWlmSazt4ynpIb0A2XDopQzkyFyRXbotYXJNnNzhzrXRHZD8eMloAAgAtAAAEtAWwAAMABwAVQAoAAwMGBwJyAQhyACsrMjIRMzAxQREjESEVITUC6/kCwvt5BbD6UAWwyMgAAQCA/+wEvwWwABUAE0AJAREGCwJyBglyACsrETMyMDFBMxEUBgYjIiYmNREzERQWFjMyNjY1A8X6kPeYnfaN+kiEWlqDSAWw/DOm4HFx4KYDzfwzaYdAQIdpAAACABEAAAUbBbAABAAJABdACwAGCAEJAnIDCAhyACsyKzISOTkwMUEBIQEjAQETIwEChwF/ARX99rv+zwF8NLz9+AEKBKb6UAWw+1r+9gWwAAQALwAABuYFsAAFAAoADwAVABtADRAMAQoCchMSDgQJCHIAKzIyMjIrMjIyMDFBATMDASMDExMjAQETMwEjAwETIwEDAgEBIpgR/sqerusVqP6vBNXo+v6vqPcBHyqe/s8QAUcEaf7d+3MFsPug/rAFsPujBF36UAWw+5T+vASNASMAAAEAJgAABOkFsAALABpADgcECgEECQMLAnIGCQhyACsyKzISFzkwMUEBASEBASEBASEBAQFTATUBNQEh/kgBw/7c/sP+w/7bAcT+RwWw/e0CE/0v/SECHf3jAt8C0QABAAgAAATZBbAACAAXQAwEBwEDBgMIAnIGCHIAKysyEhc5MDFBAQEhAREjEQEBHwFSAVIBFv4W/f4WBbD9SQK3/Gj96AIYA5gAAAMAUAAABI4FsAADAAkADQAfQA8EDAwJDQJyBwMDAgIGCHIAKzIRMxEzKzIyETMwMWUVITUBASM1ATMjFSE1BI78DQPc/IGoA4KlXfw8x8fHBE76658FEcjIAAEAhf66AhoGjwAHAA60AwYCBwYALy8zETMwMUEVIxEzFSERAhqkpP5rBo+6+aC7B9UAAQAS/4MDYwWwAAMACbIBAgAALz8wMUUBMwECcv2g8QJgfQYt+dMAAAEAC/66AaIGjwAHAA60BQQAAQQALy8zETMwMVM1IREhNTMRCwGX/mmmBdW6+Cu7BmAAAgA2AtkDOAWwAAQACQAWQAkIBwcGAAUCAwIAP80yOTkzETMwMUEDIwEzEwMnMwEBwcHKASuMgcEsjQEqBMv+DgLX/SkB8uX9KQABAAL/RAOSAAAAAwAIsQIDAC8zMDFhFSE1A5L8cLy8AAEAOATTAgwGAAADAAqyA4ACAC8azTAxQRMjAQFJw8n+9QYA/tMBLQACAFb/7AP5BE4AGwA6AClAFSssHiceOjoPJzELchgZCnIJBQ8HcgArMjIrMisyEjkvMxESOTkwMWURNCYmIyIGBhUjND4CMzIWFhURFBYXFSMmJhMXIyIOAhUUFhYzMjY2NxcOAyMiJiY1ND4CMwLeKlVAO1Yw8D52pGZ6vW0VFPcREyMCrUNmRCIoTTdKb0ACTgw6XYFUaqZeQX+4dtkCBDpULihEK0B4XjZSpXz+H0p1KxAneQHylRkwRCsrRyg9WShrKV5VNlWRXFaFWi8AAwB9/+wEMAYAAAQAGgAvABlADiEWB3IrCwtyBApyAAByACsrKzIrMjAxUzMRByMBFRQOAiMiLgInNT4DMzIeAgc1NC4CIyIOAgcVHgIzMj4CffEX2gOzNWudZ2WWZT4NDT5llWRon2o18Rg3XUVAXD4jBgk7bFVDXDcZBgD65+cCJxV4yZRRTIzCdUN2wY1MUJPKjxVJgWI5LExkOrVLfUs2YYIAAAEATv/sA/EETgAnABlADB0ZGRQHcgQEAAkLcgArMjIvKzIvMjAxZTI2NjczDgIjIi4CNTU0PgIzMhYWFyMuAiMiDgIVFRQeAgI2O187A+MCeMZ4fLh6PT16uHuCxHEC4wM1X0JJYDYXFjdgrC9UN2msZVWWxHAjcMWWVWe3eTxhOjtlfUMjQ35jOwAAAwBQ/+wEAgYAAAQAGgAvABlADSEEBBYLcisLB3IBAHIAKysyKzIvMjAxZREzESMBNTQ+AjMyHgIXFQ4DIyIuAjcVFB4CMzI2Njc1LgMjIg4CAxDy2/0pOm6eY2KUaD4NDT5olWNinW468Rs6XUFSaj0LBiU+Wz5CXDsc4AUg+gACERV7y5NPTI3Dd0N0wIxMUpTJixVKgGE3SHtMtTtmTSs4YoIAAAEAUf/sBAoETgArAB9AEGcTAQYTEhIAGQsHciQAC3IAKzIrMhE5LzNfXTAxRSIuAjU1ND4CMzIeAhUVITUhNS4CIyIOAhUVFB4CMzI2NxcOAgJZeMGHSEqEtGl0rnM5/LwCVgIvYFA8XT4hJ0xsRVeIMn8jcKEUT47Abyh/zpNOTo3CdWetE0FyRjNgh1QoR3laM0ZAezNdOgACACsAAALVBhUAEQAVABVACxQVBnINBgFyAQpyACsrMisyMDFhIxE0NjYzMhYXByYmIyIGBhUXFSE1AcLxW6p0JEYhBhQvGzdPKd/9igSieaVVCQm6BQQpTjlosLAAAwBS/lUEDAROABMAKQA+ABtADzAlC3I6GgdyDgYPcgAGcgArKzIrMisyMDFBMxEUBgYjIiYmJzcWFjMyNjY1EQE1ND4CMzIeAhcVDgMjIi4CNxUUHgIzMjY2NzUuAyMiDgIDMdt83pI+l40vcTqMTVN1QP03PHCgZWmVZDkODT5mlWVjn3E88R09X0FVbTsMBiU+XkBBYD0eBDr75JLMayRPQI5FQD12VQMs/swVe8uTT0yNw3dDdMCMTFKUyYsVSoBhN0h7TLU7Zk0rOGKCAAIAegAAA/oGAAADABoAF0AMEQIWCgdyAwByAgpyACsrKzIRMzAxQREjERMnPgMzMh4CFREjETQmJiMiDgIBavDGTgE9b5xfUIFeMfItVj5BY0IhBgD6AAYA/EUBcL6NTSxhm2/9SQK5TlwpNFp2AAACAHwAAAGQBdYAAwAPABC3Bw0DBnICCnIAKyvOMjAxQREjEQM0NjMyFhUUBiMiJgF+8hBJQUBKSkBBSQQ6+8YEOgEcN0lJNzZISAAAAv+r/ksBhwXWABEAHQATQAkNBg9yFRsABnIAK84yKzIwMVMzERQGBiMiJic3FhYzMjY2NQM0NjMyFhUUBiMiJojyTJRrIEUfARUvFSs6HhVKQEFJSUFASgQ6+2hvmU8JCLwEBR5ANQW0N0lJNzZISAAAAwB9AAAENwYAAAMACQANAB1AEQYHCwUMCAYCCQYDAHIKAgpyACsyKz8SFzkwMUERIxEJAic3ARMBNwEBb/IDkv4p/v4/wwEyNP6hmAHeBgD6AAYA/jr99v74zPEBVfvGAfyp/VsAAQCMAAABfgYAAAMADLUDAHICCnIAKyswMUERIxEBfvIGAPoABgAAAAMAfAAABnwETgAEABsAMgAhQBEpEgIuIiIXCwMGcgsHcgIKcgArKysRMzMRMxEzMzAxQREjETMDJzQ+AjMyHgIVESMRNCYmIyIOAgUHND4CMzIeAhURIxE0JiYjIg4CAW3x4xlSOGyhakp7WzHxL1c8RF88HAKfcTdrnmZTg1ww8i9WPDhVOh0DXvyiBDr+CwFwvo1NK1yQZv0vArxPWic0WnYDGWKvhUwtYJls/UQCvVJaIylJXgACAHoAAAP6BE4ABAAbABlADRICFwsDBnILB3ICCnIAKysrETMRMzAxQREjETMDJz4DMzIeAhURIxE0JiYjIg4CAWvx4x1OAT9xnmFOf1sw8i1VPz5iQyQDU/ytBDr+CwFzwIpLK2CZb/1FArxOWyc0WnYAAAIATv/sBDwETgAVACsAELccEQtyJwYHcgArMisyMDFTNTQ+AjMyHgIVFRQOAiMiLgI3FRQeAjMyPgI1NTQuAiMiDgJORIG7dne7gkREgrp2d7uCRPEeQGRFQ2NAHx9BY0REY0AeAhEXdcmVU1OVyXUXdciVU1OVyIwXSYJiODhigkkXSIFkOTlkgQAAAwB9/mAELwROAAQAGgAvABlADiEWB3IrCwtyAwZyAg5yACsrKzIrMjAxQREjETMBFRQOAiMiLgInNT4DMzIeAgc1NC4CIyIOAgcVHgIzMj4CAW7x3gLUN2ucZmWXaD8NDT9olmRmnmw28Rw8XUFAXD4iBww6a1RBXDscA2r69gXa/e0VdsmVUkuKu3BRd8KMTE+Ry5EVS4FiNytMZTvCSHhHOGOCAAMAUP5gBAIETgAEABoALwAZQA4hFgtyKwsHcgQOcgMGcgArKysyKzIwMUERNzMRATU0PgIzMh4CFxUOAyMiLgI3FRQeAjMyNjY3NS4DIyIOAgMPHNf8TjhunmdklWc+Dg0+aJZlZZ5tOfEbPFxBVW07DAckP11AQV47HP5gBQPX+iYDshV7y5JPTI3Cd0N0wIxNUpXJixVKgWM4Sn1MtTtnTSs4Y4IAAAIAfQAAArkETgAEABYAGUANBgkJBRQHcgMGcgIKcgArKysyMhEzMDFBESMRMyUHJiYjIg4CBwc0PgIzMhYBbvHmAVYCFjMZPl4/IgM3KFF7URYzA2z8lAQ6B+AEBCNBXDkEZq6ESggAAQBJ/+wDxwROADUAF0ALGwAOMikLchcOB3IAKzIrMhE5OTAxQTQmJicuAzU0PgIzMhYWFSM0JiYjIgYGFRQeAhceAhUUDgIjIiYmNTMeAjMyNjYC2yRlYlaPZjg6bJtgiMNo8StWQT5RJxUyV0J8s2A9dKFkk8xp6QRDZTZBWC4BJSQ7MBQTNUxoREJ2WjRbm2ErSy8nPiUbKyMeDhpRf2FId1cwaaVZQ08jIz0AAgAK/+wCdQVDAAMAFQATQAkKEQtyBAIDBnIAKzIvKzIwMUEVITUTMxEUFhYzMjY3FwYGIyImJjUCbP2esPEdNCMZLg4BHk8zU4BIBDqwsAEJ++gyNRIGA7gJDjuGbwAAAgB3/+wD+QQ6AAQAGwAVQAoBEQZyGAMDCwtyACsyLzIrMjAxZREzESMTNxQOAiMiLgI1ETMRFB4CMzI2NgMH8uQUUTBknG1PhF808RwwQCRndzP/Azv7xgHgAm23h0suYJprArv9QztPMBRRigACABYAAAPfBDoABAAJABdACwAGCAEJBnIDCApyACsyKzISOTkwMWUBMwEjAwEXIwEB3AEJ+v6InLoBDg2c/oa/A3v7xgQ6/IG7BDoABAAjAAAFyAQ6AAUACgAPABUAJEAUBwsAEQMUBgkQDAEKBnISDgQJCnIAKzIyMisyMjISFzkwMWUTMwcDIwMTFyMBARMzASMDExcjAycBovqaKvyKd8MQmv7bA/296/7cmrr3H4r/KvADSvz8wgQ6/LLsBDr8vANE+8YEOvzA+gM/+wAAAQAfAAAD6gQ6AAsAGkAOBwQKAQQJAwsGcgYJCnIAKzIrMhIXOTAxQRMTIQEBIQMDIQEBATTO0gEJ/rgBVf733Nz+9gFU/rkEOv6ZAWf97f3ZAXb+igInAhMAAgAM/ksD3gQ6ABMAGAAZQA0XFhUDCAIYBnIPCA9yACsyKzISFzkwMWUBIQEOAyMiJicnFhYzMjY2NwMBFwcBAbYBJgEC/k4PME1yUSA7GgEKHQk8UDMSWAEBK6f+d3YDxPshKF5VNQsGuAECHUA2BJb81v4rBFMAAwBRAAADwQQ6AAMACQANABxADQQMDAkNBnIHAwMGAhIAPzMzETMrMjIRMzAxZRUhNQEBIzUBMyMVITUDwfzaAxD9QpwCuqBd/Q/AwMAC5PxcmwOfwMAAAAIAOP6UAo4GPQARACUAGUAKHQkKChwcEhMBAAAvMi8zOS8zEjk5MDFBFwYGFRUUBgYjNTI2NTU0NjYTBy4CNTU0JiYjNTIWFhUVFBYWAl4wZ01VuJVnWkGcuDCInEEoVUSVuFUhTwY9iSOyc85kpGCKeGbOabeL+QeKJ4u3acxFYzeLYaNmzE2DYAAAAQCv/vIBUAWwAAMACbIAAgEALz8wMUERIxEBUKEFsPlCBr4AAgAc/pQCcwY9ABMAJgAbQAseCwoKHx8BFRQAAQAvMy8zEjkvMxI5OTAxUzceAhUVFBYWMxUiJiY1NTQmJgMnPgI1NTQ2NjMVIgYVFRQGBhwwiZxAKFZElLpVIE8VMEVOIVW6lGZcQJwFtIkmi7dpzkNkN4RdoWTOTYRg+PeKGGCDTcxmoF2EeWbMabeLAAEAdQGGBNcDLwAfABtACwwAABYGgBwGEBAGAC8zLxEzGhDNMi8yMDFBNxQOAiMiJicmJiMiBgYVIzQ+AjMyFhcWFjMyNjYEHrkwV3lIVIFKLlAuLUAkvjBXeEhUh0YwTiwtRCYDEQFWkWo7Q0QsLy9WOVePZzhGQS4uM1oAAAIAhf6TAZkETQADAA8ADLMBBw0AAC8v3c4wMVMTMxMTFAYjIiY1NDYzMhaSGc4ZB0lBQEpKQEFJ/pMEA/v9BTo2S0s2NkpKAAMAZ/8LBAsFJgADAAcALwAlQBICASUlIQMcB3IHBAgIDAYRDXIAK83MMxI5OSvNzDMSOTkwMUERIxETESMRNzI2NjczDgIjIi4CNTU0PgIzMhYWFyMuAiMiDgIVFRQeAgKtv7+/YTtgOgPkA3nFeHy5ejw8e7h7gsRxA+QDNV9CSWA2FxY3YAUm/t8BIfsF/uABIIEvVDdprGVVlsRwI3DFllVnt3k8YTo7ZX1DI0N+YzsAAAMAXwAABHoFxAADAAcAIgAhQBAGBQUBHxYFcgwNDQICAQxyACsyETMRMysyETkvMzAxYSE1IQEhNSElExYGByc+AjUDNDY2MzIWFhUjNCYmIyIGBgR6++kEFv67/SsC1f68FwFHUbYhIw0Vc8qDi8Jm8jhbNTZXMscBkcP0/ZRglytGCEVdKQJ1isNoZrV4S1koNmoAAAYAXP/lBU4E8QATACcAKwAvADMANwAOtQ8ZBSMNcgArMi8zMDFBFB4CMzI+AjU0LgIjIg4CBzQ+AjMyHgIVFA4CIyIuAgEHJzcBByc3ASc3FwEnNxcBMEFzl1dXl3NAQHOXV1eXc0GxXaPYe3vYpFxcpNh7e9ijXQTPyojK/ObKhsoDoMqIyvvYyobKAmBdpHpFRXqkXV6iekVFeqJeheSqX1+q5IWF5KtgYKvkAorOjM77w86Lzf6nzovNAybOi84ABQANAAAEMgWwAAMABwAMABEAFQAtQBYLEBAGBxIVFQgOAwMCAhEUDHIJEQRyACsyKxI5LzMSOTkyETPOMjMRMzAxQRUhNQEVITUlASEBIwMBByMBAREjEQPL/JwDZPycAXkBSAEK/l6S5AFLIpL+XAKM+gLjlZX+3ZSU8QL//JQDbPz5ZQNs/U79AgL+AAIAif7yAWoFsAADAAcADbQBAgYHAgA/3d7NMDFBIxEzEREjEQFq4eHh/vIDGQOl/QoC9gACAFz+JgSMBcUALwBhAB5AE1M/AAEFK101MTAPIQxPRB0UEXIAKzIvMxc5MDFlNTI2NjU0LgInLgM1ND4CMzIWFhUjNCYmIyIGBhUUHgIXHgMVFA4CAxUiBgYVFB4CFx4DFRQOAiMiLgI1NxQeAjMyNjY1NC4CJy4DNTQ+AgKvTGo4IEp9XW+uej9Hhbl0neN68T11V1x0OBxEfGBysHpARH2w8EthLhtGfmFxsHg/R4W4c2O+mlvxNFVoNFR1PR9Ie1xvsHpBQXiqfIIwVTUqPzUyHR5HYIdeVYpiNWS/ikJrQDFRMis/MS0aHkhfhlxQfFQsAu+EMFM1LUE0LxwfR1+HXliKXzErYaR4AkRbNBcuTzMoPDMwGx5HYIZcTntVLgAAAgBjBOUDLAXNAAsAFwAOtAMJCQ8VAC8zMy8zMDFTNDYzMhYVFAYjIiYlNDYzMhYVFAYjIiZjRDg5REQ5OEQBz0Q5OEVFODlEBVkxQ0MxMENDLzFDQzEwQ0MAAwBa/+sF5QXEAB8AMwBHAB9ADh0EBCUlQxQNDS8vOQNyACsyETMRMy8zETMRMzAxQTMUBiMiJiY1NTQ2NjMyFhUjNCYjIgYGFRUUFhYzMjYlFB4CMzI+AjU0LgIjIg4CBzQSNiQzMgQWEhUUAgYEIyIkJgIDyZazmmubVVWba5q0ll1bQVktLVlBW1z9Blyj13t616JcXKPWenvXo1x1bsQBAZOTAQHDbm7D/v+Tk/7/xG4CVZ2dYq5zdXOuYp2dYlVBdEp2S3RBVOeF5atfX6vmhIXkql9fquSFnwEQy3Fxy/7wn5/+8M1ycs0BEAAAAgCOArQDDgXFABcAMQAatTEaGg0WKrgBALIIDQMAPzMa3MQSOS8zMDFBETQmJiMiBhUnNDY2MzIWFhURFBYXIyYTFyMiBgYVFBYzMjY2NRcOAiMiJjU0NjYzAkwaNilDTaVNi11XgUkMDqoYKQGTO00lOz8qVToSDz5jRHiBS5dyA14BVCo7HjQzDkRpPD56XP7GMVgsSQFycR80HyoxJjgYcSBELHtnSmc2//8AVwCJA4UDpwQmAZPr/gAHAZMBVf/+AAIAfwF3A78DIgADAAcAErYGBwMGAgIDAC8zETMSOS8wMUEVITUFESMRA7/8wANAvgMipaVL/qABYAAEAFn/6wXlBcQAHgAvAEMAVwA1QBsfGxggBAICAQEPKQ0NNTVTDA8PSVMTcj9JA3IAKzIrEjkvMxEzETMvMxI5fS8zEhc5MDFBIyczPgI1NCYmIyMRIxEhMhYWFRQGBgciBiMOAiM3MhYVFRQWFxUjJiY1NTQmJRQeAjMyPgI1NC4CIyIOAgc0EjYkMzIEFhIVFAIGBCMiJCYCAzjYAsEsTC4hT0OFkQEWY5FPMmFGAwcDEQkJHhWccgcKlQoDQv1RW6TXenvWolxcotZ7etekW3ZuxAEBk5MBAcNvb8P+/5OT/v/EbgKOggEbNScxOhn9MQNQOXNWNlQ9Ew4KCQJjh2g2JUMXEBpgFjRJREuF5atfX6vmhIXkql9fquSFnwEQy3Fxy/7wn5/+8M1ycs0BEAABAJ0FEANEBaoAAwAIsQMCAC8zMDFBFSE1A0T9WQWqmpoAAgCBA7ECjgXFAA8AGwAPtRMMwBkEAwA/MxrMMjAxUzQ2NjMyFhYVFAYGIyImJjcUFjMyNjU0JiMiBoFIeUdIdkdHdkhHeUiHTDU1SEg1NUwEuUl6SUl6SUl5RkZ5STZJSDc4SkoAAwBcAAED8AT9AAMABwALABK3CwIDAwQKEnIAKy85LzMyMDFBFSE1AREjEQEVITUD8PxsAjzVAgv8rQODxMQBevw8A8T7xcHBAAABAD0CmwKwBbsAHAATsRwCuAEAswsTA3IAKzIazDIwMUEVITUBPgI1NCYjIgYVIzQ2NjMyFhYVFAYGBwcCsP2fAR8pMRc4NUA/tkmHXl+FRzBbQ40DLJF6AQklPzQSKzdHM0l6SDpsTDddXDd2AAIANwKQAqkFuwAZADMALEAMHBgAABoaECwpKSQQuAEAtQsLCBADcgArMjIvGhDMMi8yETkvMxI5OTAxQTMyNjY1NCYjIgYVIzQ2NjMyFhYVFAYGIyMVNTMyFhYVFAYGIyImJjUzFBYzMjY1NCYmIwEOVys4HTdAMUO2UIZPW4pNR31UdXVdhEVUkVpLjVu3SD1BPyNAKwRsGSweJDcpJUdkNDNkSjlYMSlSK1hGSmg2MWpWJzg5KyYuFQAAAQBvBNMCQgYAAAMACrIBgAAALxrNMDFTEyEBb8MBEP7wBNMBLf7TAAMAk/5gBCQEOgAEABoAHgAZQAwdBQAWCxNyAxJyHAAALzIrKzIROS8wMUEzESMnNzcUDgIjIiYmJwMzFB4CMzI+AgEzESMDMvLfEyNfK1mIXUp2VhwfiR42SStPZzsZ/T7w8AQ6+8b6/QJywI5OK1xKARFacj0YMVl5Aov6JgAAAQBJAAADVAWwAAwADrYDCwJyABJyACsrzTAxYSMRIyImJjU0NjYzIQNUyVaf23Jy258BHwIIedSHhtR6AAABAJACRgGqA04ACwAIsQMJAC8zMDFTNDYzMhYVFAYjIiaQS0JCS0tCQksCyThNTTg4S0sAAQBs/j8BygAEABMAEbYLCoATAgASAD8yMhrMMjAxdzMHFhYVFA4CIycyNjY1NCYmJ4uzDDlfKlN7UQcnPiUgQzUEOApNVjNSOyCIEyggHyISBAAAAQCCApsCAQWvAAYACrMGAnIBAC8rMDFBESMRBzUlAgG1ygFsBa/87AJAMY92AAIAeQKzAygFxQARACMAELYXDiAFA3IOAC8rMhEzMDFTNTQ2NjMyFhYVFRQGBiMiJiY3FRQWFjMyNjY1NTQmJiMiBgZ5VZlqappTU5lpa5pVqCZQPDtNJyhNPDtPJgQTUGegW1ugZ1Bnn1pan7dQPGA3N2A8UDtgNzheAP//AF4AiwOXA6gEJgGUCQAABwGUAX0AAP//AF8AAAV9BawEJwHh/90CmAAnAZUBHAAIAAcCOwK+AAD//wBTAAAFxQWvBCcBlQDxAAgAJwHh/9ECmwAHAeADFQAA//8AZgAABgAFuwQnAZUBrwAIACcCOwNBAAAABwI6AC8CmwACAEb+fgOnBE4AIQAtABhACgAAJSUrEBERDRYALzMzLz8zLzMvMDFBMxQGBgcOAhUUFhYzMjY2NzMOAiMiJiY1NDY2Nz4CExQGIyImNTQ2MzIWAZjfHUM8LEotLFM7NFg3AfEBdMN6iMFmSHE/JScO90lAQUpKQUBJApZdfWU8LFBdPj9WKylUQH6tWFuse1qSfjsjSFQBajZLSzY2SkoABv/8AAAHTgWwAAQACAAMABAAFAAYADFAGAAXFwgHFBMHEwcTAg0DGAJyDAsLDgIIcgArMjIRMysyMhE5OS8vETMRMzIRMzAxQQEhATMTFSE1ARUhNRMTIwMBFSE1ARUhNQPY/UP+4QM8mYD9FQXo/SMYPfE9Ayf9igLH/SQFGProBbD8etLS/pfBwQTv+lAFsP2hwcECX8HBAAIATADLA+sEdwADAAcADLMEBgIAAC8vMzIwMXcnARcDATcB3pIDC5KQ/PWSAwvLkQMbkvzmAxqS/OUAAAMAaf+iBSIF7QADABsAMwAXQAsBAC8KIxYDcgoJcgArKzIRMzIzMDFBASMBExUUAgYGIyIuAzU1NBI2NjMyHgMHNTQuAyMiDgIVFRQeAzMyPgIFEPwypwPQt1ag3odruZZrOVih3YZsupVpOfweO1ZvQ1OCWzAfPFduQlSCWi8F7fm1Bkv9E1Cl/vq4YT93rd2EUKUBBblhP3is3dRSYZ95UipBf7t6UmKfelMqQYG8AAACAJUAAASBBbAAAwAZAB1ADg8ODgMZBAQDAAJyAwhyACsrETkvMxE5LzMwMVMzESMTITIWFhUUBgYjITUhMjY2NTQmJiMjlfHxYAGKp+R3d+Sn/t4BImJ3Nzd3YvoFsPpQBJhxxn9+xnG/RnA+QHFIAAABAIr/7ASeBhUAOQAZQA0jGzYIAgpyCAFyGwtyACsrKxEzETMwMUERIxE0PgIzMhYWFRQOAhUUHgMVFAYGIyImJic3FhYzMjY2NTQuAzU0PgI1NCYmIyIGBgF68D5zoGRxtWsjLiNBYGBBZryBNHJfGzEhfEdAVCpBYGFBJTAlLU4yO1UuBFH7rwRTcKhwOk6cd01iSUs3MFFPW3NMdJ9REh0RvxQsKUcuNVJMV3JPQFlLUzo4Tyo1cwADAEj/6waGBE8AFAAyAF4AN0AcVzMzMhdGRRQlAAMpF0UXRQ8fKQtyTD4+BQ8HcgArMjIRMysyEjk5Ly8SFzkRMxEzMhEzMDFlETQmJiMiBgYVJzQ+AjMyFhYVEQMXIyIGBhUUFhYzMj4CNxcOAiMiJiY1ND4CMwEiLgI1NTQ+AhcyHgIVFSE1ITU0JiYjIg4CFRUUHgIzMjY3Fw4CAuEqUztAXjLxQXamZn66aMAB501pNShSPzBjVDMBdRpztH17qlg9eLF1AsN8voNCQn6xbmunczv8zwJCKlxLQF09HiJHcU9vijdHHW2btwISPlgvKkgrEkh4WjFXroL+EwGppDBOLipDJiQ4PxyVMGRDUpZkT3tVLf1oTo7Bczl3xZBPAUOAtHCMpx1EbD81Xn5JOUd5XDQ9H6EXOSsAAgBo/+wEQgYsADQAOAAZQAs2IBYWASoMC3I4AQAvMysyEjkvMzMwMVM3FgQWEhUVFA4CIyIuAjU0PgIzMhYWFyc0LgIjIg4CFRQeAjMyPgI1NTQuAiUBJwH1S6sBGs5vSoW1bG20g0Y/d6VmcbZtBFchQmRDQGJDIiJBXjw8XUAhYqnYAm/92UsCKAVtvyWi8f7JvFV/1JpTS4axZnK5hUhnqWQCHUE4IyxTdko5alQxOGSHT2Wn+7R1MP6VawFqAAADAEMAlgQ6BMkAAwAPABsAE7cZEwIHDQMCEgA/3cYyEMYyMDFBFSE1ATQ2MzIWFRQGIyImETQ2MzIWFRQGIyImBDr8CQFyS0JCS0tCQktLQkJLS0JCSwMYzs4BLjhLSzg4Skr9CjhLSzg3S0sAAAMATv91BDwEvQADABkALwAZQAwgAQEVC3IrAAAKB3IAKzIvMisyLzIwMUEBIwEBNTQ+AjMyHgIVFRQOAiMiLgI3FRQeAjMyPgI1NTQuAiMiDgID3P1pjwKX/QFEgbt2d7uCRESCunZ3u4JE8R5AZEVDY0AfH0FjRERjQB4Evfq4BUj9VBd1yZVTU5XJdRd1yJVTU5XIjBdJgmI4OGKCSRdIgWQ5OWSBAAMAgf5gBDQGAAADABkALwAbQA8rCiAVB3IKC3IDAHICDnIAKysrKzIRMzAxQREjEQEVFA4CIyIuAic1PgMzMh4CBzU0LgIjIg4CBxUeAzMyPgIBc/IDszdrnGZll2g/DQ0/aJVkZ55rN/EcPF1BQFw+IwYIJT1bQEFcOxwGAPhgB6D8JxV2yZVSS4q7cFF3woxMT5HLkRVLgWI3K0xlO8I3X0gpOGOCAAQAUP/sBK0GAAAEABoALwAzAB1ADyEEBBYLcjMyKwsHcgEAcgArKzLOMisyLzIwMWURMxEjATU0PgIzMh4CFxUOAyMiLgI3FRQeAjMyNjY3NS4DIyIOAgEVITUDEPLb/Sk6bp5jYpRoPg0NPmiVY2KdbjrxGzpdQVJqPQsGJT5bPkJcOxwDbP1g4AUg+gACERV7y5NPTI3Dd0N0wIxMUpTJixVKgGE3SHtMtTtmTSs4YoIDAaenAAAEAB8AAAWcBbAAAwAHAAsADwAfQA8DAoAHBgYKDAsCcg0KCHIAKzIrMhE5LzMazDIwMUEVITUBFSE1ExEjESERIxEFnPqDBDz8+z76BIP7BKuenv6lx8cCYPpQBbD6UAWwAAEAkAAAAYEEOgADAAy1AwZyAgpyACsrMDFBESMRAYHxBDr7xgQ6AAADAI0AAARtBDoAAwAJAA0AH0APDAcHCwYGAgkDBnIKAgpyACsyKzIROS8zMxEzMDFBESMRIQEhJzMBEwE3AQF+8QPG/f/+9B+zAU0T/pm/AdsEOvvGBDr9ddoBsfvGAdiJ/Z8AAwAgAAAENgWwAAMABwALABtADQIKAAcGBgoLAnIKCHIAKysRMxEzMhEzMDFBFQU1ARUhNRMRIxECjv2SBBb9JUX6A66Qu5D91MfHBOn6UAWwAAIAIAAAAjIGAAADAAcAE0AJAgYABwByBgpyACsrMhEzMDFBFQU1AREjEQIy/e4BfPEDsJC7kAML+gAGAAAAAwCQ/ksFDAWwAAMABwAZAB1ADhUOBgcHAwhyCQUEAAJyACsyMjIrMhEzLzMwMVMzESMTNwEHETMRFAYGIyImJzcWFjMyNjY1kPv7S7ADN7H7V6FxIz4kDhU3Fyo6HgWw+lAFO3X6xXUFsPoYe6pYBwrDBgYqUToAAgB9/ksEBgROAAQAKgAZQA4cFQ9yJgsHcgMGcgIKcgArKysyKzIwMUERIxEzAwc0PgIzMh4CFREUBgYjIiYnNxYWMzI2NjURNC4CIyIOAgFu8d4nKTlqll5Rg10zVp5vIz4iDhM7Fio5HxozSS9Ja0UiA1P8rQQ6/gcCcsGOTjBnpXP9I3moVgcKwQYGKE86AttDXTYZNFp4AAUAZf/rBzQFxQAjACcAKwAvADMAM0AaLy4uJjIoMwJyKScmCHIVEhIWGQkEBwcDAAMAPzIyETM/MzMRMysyMisyMhE5LzMwMUEyFhcVJiYjIg4CFREUHgIzMjY3FQYGIyIuAjURND4CARUhNRMRIxEBFSE1ARUhNQKqTZVDQpRPTn5aLzBaf05OlEFDk02C1pxTU5vVBQz8+0f7A1T9YAMA/QAFxQ0IxgwPM2aWZP7OZJdmNA8MxgcOV5/bhAEwhNufV/sCx8cE6fpQBbD9oMTEAmDIyAADAFn/6wb2BE8AKgBAAFYAJ0ATJAAARzwTEhI8UhkLCzEHcjwLcgArKzIRMzIROS8zETMzETMwMUUiLgI1NTQ+AhcyHgIVFSE1ITU0JiYjIg4CFRUUHgIzMjY3FwYGATU0PgIzMh4CFRUUDgIjIi4CNxUUHgIzMj4CNTU0LgIjIg4CBU10uYNHR4CuZ3CpcTr81QI9LV5LOFg8HiJGaEZtjDhMN8f6fEOAuHZ4uYBCQn+5d3e5gEPyHT5hRURhPh0dPmJFRGE9HRVRkMNzKnfHlFEBRoGxbY6tGkJrPzdigEkqRnxfNjYnmzBSAiYXdcmVU1OVyXUXdcmVU1OVyYwXSYJjODhjgkkXSIFkOTlkgQAAAQCJAAAClAYVABEADrYNBgFyAQpyACsrMjAxYSMRNDY2MzIWFwcmJiMiBgYVAXrxWaZzKEonGBMtHzVIJgSieaVVDAm1BQUqUDkAAAEAVf/sBSMFxAAsABtADQ8ABgkJABoiA3IACXIAKysyETkvMxEzMDFFIi4CNTUhFSEVFB4CMzI+AjU1NC4CIyIGByc+AjMyHgIVFRQOAgK9l+ebTwQg/NonVoxlWIhdLzBmpXeEvDswGHm0b6T8q1hfp98UXbH5mo/DIU+KZztKg61ie2Otg0syGMINLCFlt/2Xe5f8t2MAAf/e/ksC1AYVACcAKUAVFAICFScGch8iIh4bAXILDg4KBw9yACsyMhEzKzIyETMrMjIRMzAxQRUjERQGBiMiJic3FhYzMjY2NREjNTM1NDY2MzIWFwcmJiMiBgYVFQKJz1ObbCQ8Ig8PPxArOBumplmmdCdLJhcUMR80RyQEOrD8MXekVQcKuwUHKU84A8+waHmlVQwJuAUFKE85aAADAFv/7AWvBisACQAhADkAHUAOBQYGKSkAABwDcjUQCXIAKzIrMi8yETkRMzAxQTMUBgYjNTI2NhMVFAIGBiMiLgM1NTQSNjYzMh4DBzU0LgMjIg4CFRUUHgMzMj4CBPq1UaeAS1UjGlag3odqupZrOVih3oVsu5RqOPweO1ZvQ1KCXDAfPFdvQVSDWi4GK4e+Y5FDff0sUKX++rhhP3et3YRQpQEFuWE/eKzd1FJhn3lSKkF/u3pSYp96UypBgbwAAAMATf/sBLcEqAAJAB8ANQAVQAomGwtyMQAAEAdyACsyLzIrMjAxQTMUBgYjNTI2NgE1ND4CMzIeAhUVFA4CIyIuAjcVFB4CMzI+AjU1NC4CIyIOAgQWoUOVe0tMG/w3RIG7dne8gUREgbp3d7uCRPEeQWNFRGI/IB9AY0VEYkEeBKhzplh3PnD9tRd1yZVTU5XJdRd1yJVTU5XIjBdJgmI4OGKCSRdIgWQ5OWSBAAIAgP/sBjoGAgAJAB8AGUAMBQoKAAAVAnIbEAlyACsyKzIvMhEzMDFBMxQGBiM1MjY2JTMRFAYGIyImJjURMxEUFhYzMjY2NQWLr0+4nmlqI/46+pD3mJ32jfpIhFpag0gGApHIaJJGiA/8M6bgcXHgpgPN/DNph0BAh2kAAAMAd//sBSQElQAJAA4AJQAdQA4FCwsAABsGciIODhULcgArMi8yKzIvMhEzMDFBMxQGBiM3MjY2AREzESMTNxQOAiMiLgI1ETMRFB4CMzI2NgSGnkGdiwFeVRf+gfLkFFEwZJxtT4RfNPEcMEAkZ3czBJV0nlB9MWX8uQM7+8YB4AJtt4dLLmCaawK7/UM7TzAUUYoAAAH/rv5LAZIEOgARAA62DQYPcgEGcgArKzIwMVMzERQGBiMiJic3FhYzMjY2NaHxVZ9uJDwiDhM6FSo6HwQ6+4h5qFYHCrsGBitSOgABAFf/7AP2BFAAKgAZQAwRFBQAGQsLciQAB3IAKzIrMhI5LzMwMUEyHgIVFRQOAiciLgI1NSEVIRUUFhYzMj4CNTU0LgIjIgYHJzY2AgB0uYNGRoCuZ3CpcToDK/3DLV9KOFc8HyNFaEZsjDlMOMcEUFGQw3MqdsiUUQFGgbFtjq4ZQWxAOGGBSSpGfF82NiebMFIAAQCQBOEDRAYAAAgAFLcHBQUEAQOACAAvGs0yOTIRMzAxQQEVIycHIzUBAi8BFcOZmb8BEQYA/uwLnZ0NARIAAAEAbgTgAzUGAAAIABK2AQaABwQCAAAvMjIyGs05MDFBFzczFQEjATUBO5aVz/7omP7pBgCdnQv+6wEWCgD//wCdBRADRAWqBgYAcAAAAAEAdQTNAv8F5wAOABC1AQEJgAwFAC8zGswyLzAxQTMUBgYjIiY1MxQWMzI2AkyzT5Fkl6+zQ1BPQgXnU39InX04VVUAAQCBBOQBhgXVAAsACbIDCRAAPzMwMVM0NjMyFhUUBiMiJoFFPT1GRj09RQVcM0ZGMzRERAAAAgB4BI0CLQYlAA0AGQAOtBcEgBELAC8zGswyMDFTNDY2MzIWFRQGBiMiJjcUFjMyNjU0JiMiBng6Yj9dfTljPl59az4yMj09MjI+BVc5XTh5VTlcNXRWLENCLS5DQwAAAQAp/lQBnwA6ABUADrQID4ABAAAvMhrMMjAxZRcOAhUUFjMyNjcXBgYjIiY1NDY2ARZzLkopICceLA8XGU48WHsuaDo6Hj1FKB4nEQeLDx1mYjRlXQABAHcE3gNTBfMAGQAnQBMAAAEBChJADxpIEgWADQ0ODhcFAC8zMy8zLxoQzSsyMi8zLzAxQRcUBgYjIi4CIyIGFSc0NjYzMh4CMzI2AsCTOmQ/MUQ4OygmNZQ6ZD8pQz1AJyY2BfMLSXNCHCQbOC8ISHREGyQcOgACAEsE0QNYBf8AAwAHAA60AQWAAAQALzMazTIwMUETMwEhEzMDAYvk6f71/f605OEE0QEu/tIBLv7SAAACAIn+bgHw/70ACwAXAA60DwmAFQMALzMazDIwMVc0NjMyFhUUBiMiJjcUFjMyNjU0JiMiBolrS0loaElLa2UvIiAsLCAiL+xJYGBJSlxdSSEuLSIjLi4AAfyTBNP+ZwYAAAMACrIDgAIALxrNMDFBEyMB/aPEyf71BgD+0wEtAAH9YgTT/zUGAAADAAqyAYAAAC8azTAxQRMhAf1iwwEQ/vAE0wEt/tMA///8dATe/1AF8wQHAKX7/QAAAAH9OgTm/psGfQAUABC1FAIAgAsMAC8zGswyMjAxQSMnPgI1NC4CIzcyHgIVFAYH/gKzCTM+HRcqOCEHVYFXLWA5BOaPAw8dGBQcEQd5GzJGLEhECAAAAvwIBOT/MAXuAAMABwAOtAcDgAQAAC8yGs0yMDFBIwEhASMDM/4Az/7XAQACKMP29gTkAQr+9gEKAAH9Hv6X/jH/igALAAixAwkALzMwMUU0NjMyFhUUBiMiJv0eSUBASkpAQEnwNEZGNDNGRgABAM0E7AHsBkAAAwAKsgCAAQAvGs0wMVMTMwPNQd6PBOwBVP6sAAMAbgTlA7cGsAADAA8AGwAZQAoTGRkNAYAAAAcNAC8zMy8azREzETMwMUETMwMFNDYzMhYVFAYjIiYlNDYzMhYVFAYjIiYBwyzjgv4eQzk4RUU4OUMCT0Q5OUREOTlEBYcBKf7XLjFDQzEwQ0MvMUNDMTBDQ///AJACRgGqA04GBgB4AAAAAQCZAAAENwWwAAUADrYCBQJyBAhyACsrMjAxQRUhESMRBDf9XPoFsMj7GAWwAAMAGgAABaYFsAAEAAkADQAbQA0GAgcDAnINDAwFAhJyACsyMhEzKzISOTAxQQEhATMBATczAScVITUDKP34/voCU5EBov4HLJICQd/8GgUv+tEFsPpQBTd5+lDHx8cAAAMAXP/sBRUFxAADABsAMwAbQA0vCgMCAgojFgNyCglyACsrMhE5LzMRMzAxQRUhNQUVFAIGBiMiLgM1NTQSNjYzMh4DBzU0LgMjIg4CFRUUHgMzMj4CA5/+RgMwVqDeh2u5lms5WKHdhmy6lWo4/B48VW9DUoJcMB88V25CVIJaLwM5v785UKX++rhhP3et3YRQpQEFuWE/eKzd1FJhn3lSKkF/u3pSYp96UypBgbwAAgAgAAAFDwWwAAQACQAXQAsGAAIHAwJyBQIIcgArMisyEjk5MDFBASEBMwEBJzMBAsD+bv7yAfuwATf+bAqwAfsEz/sxBbD6UATT3fpQAAADAGoAAAQuBbAAAwAHAAsAG0ANAQAFBAQACAkCcgAIcgArKzIROS8zETMwMXM1IRUBNSEVATUhFWoDxPyjAvH8twOUx8cCh8LCAmHIyAABAJkAAAUUBbAABwATQAkCBgQHAnIGCHIAKysyETMwMUERIxEhESMRBRT6/Xn6BbD6UATo+xgFsAAAAwBHAAAESwWwAAMABwAQACFAEA4GBgcHDwJyDAMDAgILCHIAKzIRMxEzKzIRMxEzMDFlFSE1ARUhNQEVASM1AQE1MwRL/FwDgfyCAnH94bUBy/41tcfHxwTpyMj9NxT9LZICSwJBkgADAEwAAAW2BbAAEwAnACsAIUAQFBUVAQApCHIfHh4KCygCcgArzTIyETMrzTIyETMwMWUjIi4CNTQ2JDMzMh4CFRQGBCUzMjY2NTQuAiMjIgYGFRQeAgERIxEDZsqF2Z1VlQEJr8+D2Z1VlP72/oTMcJhPLVd/UtFtmVEtWIIBN/urTpHLe6f9jE+VzH6l+IrRUZlsU4FaL1Odb1B/WC0ENPpQBbAAAgBGAAAFZAWwABkAHQAZQAwUBwcNHAhyHQENAnIAKzIyKxE5ETMwMUEzERQCBCMjIi4CNREzERQeAjMzMjY2NQERIxEEaPyc/um2VobfoVn7M2CGU1VyoFT+6voFsP4Svf75iU6W3I0B7v4SYJJiMlmtgAHu+lAFsAADAGwAAATbBcQALQAxADUAJUASKBISLykpNBERMy4yEnIGHQNyACsyKzIyMhEzMxEzMhEzMDFBNTQuAiMiDgIVFRQeAhcVLgM1NTQ+AjMyHgIVFRQOAgc1PgMDNSEVITUhFQPNKU5vRURtTSkjQFo1ZriPVFKXz35/0ZdSUo62ZDRXPiPsAe77qAH2Au9maJ5rNjZrnmhmfr6GUQ+PDXe97YNkiuWnW1un5Ypkgu29dw6PEFGGvv2OyMjIyAAAAwBW/+sEewROABYALABBABpADS4GNDs7HRILcigGB3IAKzIrMjIRMz8wMVM1ND4CMzIeAxcVDgMjIi4CNxUUHgIzMj4CNzUuAyMiDgIBMxEUHgIzMjY3FwYGIyIuAicRVjdrnmdKd1o/KQoMOWCMXmWdbDfyGjhcQUBaPSYLCSQ+XD9BXDoaAeTPCxUcEQgOBRggOyE1Vz8lBQH7FX7SmlQyX4SlYD50v4xMTo7BiBVHelwzMlh1QkdGfmA3PGmLAdz9CSs2IQ0EAbESCyNLdlICMAACAJf+dQRuBcQAHAA6AB5ADjUAJicnHBwwHQMTCQtyACsyPzM5LzMSOTkvMDFBMzIWFhUUBgYjIi4CNTcUFhYzMjY2NTQmJiMjEzIWFhUUBgYjIzUzMjY2NTQmJiMiBgYVESMRNDY2AhuNkMpscMqITp+FUFtPjl5QcTs2aU11TonKb2vBgWNKTV0rLlxHP2c78YDTAy1ksXWMxGcuX5ZoGj9pPkFwR0h0RgMfYLB5Y6JghDViQTdfPDppRPpYBah7v20AAwAe/l8D9QQ6AAMACAANABlADggMAwQKBQEFDQZyAQ5yACsrMhIXOTAxZREjETcTMwEjAwEXIwECgfFv+/v+gaK8AQQkov6Abf3yAg6VAzj7xgQ6/MT+BDoAAgBR/+wEOgYhACwAQgAZQA0UKD4DBDMeC3ILBAFyACsyKzISFzkwMVM0NjYzMhYXByYmIyIGBhUUHgIXHgIVFRQOAiMiLgI1NTQ2NjcnLgITFRQeAjMyPgI1NTQuAiciDgLNYLF7T3ZGASqHTDZOKxApSzyWyGVEgbl1d7uBQ1mUVQI8WS91H0BiREJhPx8kRF46QmNBIATsYIpLGRq9DiccNSMSKCkrFDSf2YoVc8OSUVCPwXEWdL6AFQUcT2b9cRZIf2E4OGF/SBY6cWJDDDhhfgACAGL/7AQSBE0AHwA/AB9ADwAhPj4DAxY1KwdyDBYLcgArMisyEjkvMxI5OTAxQTMVIyIGBhUUHgIzMjY2NTMUDgIjIi4CNTQ+AgUjIi4CNTQ+AjMyHgIVIzQmJiMiBgYVFB4CMzMCDerCR2Y1HTtWOEloOPBQhqVVZ6+CSDpungFP6luXbDpCeqpnW6F8R/E5YT1JXiwZMk81wgJLdx9DNh43KxksSClYgVMoLFR5TERpSCVGKktiN011TyksVXhMKkAkKkEkHjMlFAACAFn+fQPFBbAAKAAsABVACRUCLCwpKQACcgArMi8zETMvMDFBMxUBDgIVFB4CFxceAhUUBgYHJz4CNTQmJicnLgM1NDY2NwEhFSEDPYj+mkdhMhUoPillUXxGQl4vfCAqFRk6MFFZflAlO3pd/rIDC/z1BbCN/lJUk5peL0MwHwwfFjFXUjd6ayFiIj03GRcmHgwWF0FYdkxdwc5vAdi+AAACAH3+YQQGBE4ABAAcABdADBgLAwZyAgpyCwdyEQAvKysrETMwMUERIxEzAwc0PgIzMh4CFREjETQuAiMiDgIBbvHeHEY7b51iUYNdM/IaM0kvRmdDIANT/K0EOv4HAnLBjk4qX51z+6wEUj1UMxc0XHgAAAMAdv/sBDAFxAAZACcANgAdQBANKGowIGowMA0AGmoADQtyACsvKxI5LysrMDFBMh4DFRUUDgMjIi4DNTU0PgMXIg4CFRUhNTQuAwMyPgM1NSEVFB4DAlJXk3ZTKytSdZNXVpN1VCwsU3STVjhYPB8B2BQmOkssLks4JxP+KBQoOUsFxDBkl8+E14PPmmUyMmWaz4PXhM+XZDC/M2eaZzQ0UoRjQSH7pyJDZYVTLi5ThWVDIgAAAQCj//QCXgQ6ABEADrYGDQtyAAZyACsrMjAxUzMDFBYWMzI2NxUGBiMiJiY1o/IBHTQjGS4PHk8zU4BIBDr8+jM1EwcDtwoOPIVwAAIAFf/uBE0F/AAEACYAHkAQABsEAwQCIAUAcg8WFgIKcgArMi8zKzISFzkwMUEBIQEXATIeAhcBHgIzMjYzFwYGIyImJicBAy4CIyIGByc2NgIh/vv++QGcpv69N1U/LA8BpA0dJRkJEwgDETAdSWdHHf7gcw4jLx8LHQ4EGU8C8P0QBFIIAbIYLUEo+8ofLRgBvQQGKV5PAwYBESQqEwEBsgcJAAACAGf+dgPaBcQAHgBGABlACx8RDw8hITMFGwNyACsyLzkvMxI5OTAxQQcuAiMiBgYVFB4CMzMVIyIuAjU0PgIzMhYWAzMVIyIGBhUUFhYXFx4CBxQGBgcnPgI1NCYmJycuAzU0PgIDriMuSUYoWXI2H0FoSZKWc7uHSUN/sG46YlfRko5xnlNJd0dmV3tDAUJfLYIfLRgbOS89aKh2QFSb2QWXuQsRCCxLLihEMRuMLVR1SlaGXjELFP3FiD9/YU9rQBEZFTRZSzh5aiFjITk4HxgjHAwRG0JglXBon2w3AAMAMP/0BNgEOgADAAcAGQAZQA0OFQtyBgpyCQcCAwZyACsyMjIrKzIwMUEVITUhESMRITMRFBYWMzI2NxcGBiMiJiY1BLP7fQGf8QI+8h00IxkuDgEeTzNTgEkEOrq6+8YEOvz6MzUTBwO3Cg48hXAAAAEAgP5gBDAETgAvABdADB4pBhELcgYHcgAOcgArKysRMzIwMVMRND4CMzIeAhUVFA4CIyIuAiceAjMeAjMyPgI1NTQuAiMiDgIVEYBFfq1odbB3PDZrm2VklGY+DQQtLQELPG1UQVw6Ghk5W0E8VDYZ/mAD43rBiEhUmtJ+FXPBjk1Jh7pwARwcSHVFM1x6RxVOi2k8O2R8PvwrAAEAUP6KA+kETgAtAA61GwkFAAdyACvMMy8wMUEyFhYVIzQmJiMiDgIVFRQWFhceAhcUBgYHJz4CJzQmJicuAjU1ND4CAjh+xG/kLVtFRF46GkKGZFmBRwJAXi5/ICoVARs4LJnRa0B8tgROYLaBPGI5O2V9QyNagVcdGDNZUzd6aSFiIjk2HxwmGgomhs6PI3DFllUAAAMAUP/sBH0EOgAYAC4AMgATQAkqBjIGch8UC3IAKzIrMjIwMVM1ND4CMx4CFx4CFRUUDgIjIi4CNxUUHgIzMj4CNTU0LgIjIg4CARUhNVBCgLh2Gi9BN1WHT0F+tnV2uoBC8R0+YkRCXjwcHDxfQkRiPR0DPP3DAhEXccGQUAcyNxAkhKxlFmi5jVFTlMmMF0mCYjk5YoJJF0N6XzY2X3oBz8DAAAACADz/7APuBDoAAwAVABVACgUKEQIDBnIRC3IAKysyETMyMDFBFSE1ITMRFBYWMzI2NxcGBiMiJiY1A+78TgFU8RktHR8sFSIvVjJagEUEOr6+/PIxNxUNCK4aEESQcgABAH//6wQEBDoAHgATQAkQBxkABnIZC3IAKysRMzIwMVMzERQeAjMyPgI1JgInMx4CFRQOAiMiLgI1f/IYLDsiP2BBIQI+L+4eNCA6eLh/XphsOgQ6/WpEYToaRHKMRocBBXs+nL1vd9SiXDRsqHMAAQBG/iIFhQRCAC8AGUAMKwUFGRgGciIPC3IAAC8rMisyMhEzMDFBETQ2NjMyHgIVFAYGBCMiJCYmNTQ2NjcXDgIHFB4CMzI2NjU0LgIjIgYVEQJoSn5Qeb+GR0id/v+7uv7/nEc6bEmZMkIhAitjpXqju1EjQF8+IRn+IgUcTnRCV5fCam/No15iqdh2br6bNo4xeoRAUJNzQ26vYEZ9YDcnFvrdAAIAUv4lBX8EOgAeACIAFUAKIQcZC3IgEAAGcgArMjIrMi8wMVMzERQeAjMyPgI1JiYnMx4CFRQGBgQjIi4CNQEzESNS8T9vlFZ6qGQtAkIx6iE4I0Wb/wC7lfOuXAIR8PAEOv4UdaJhK0N0lFCC+3c7l7Zsd9mpYkeV6aEB6fnrAAACAGX/6wYwBDoAHgA/ABlADAEXCgopNh8GcjYLcgArKxEzMxEzMjAxQTMeAhUUDgIjIi4CNREzERQeAjMyPgI1JgIlMwYCBxQeAzMyPgI1ETMRFA4CIyIuAzU0NjYEs+0nQSgsYaF0V4piM7AcNEQoNEcsFARM/AXuO00DDBosPikpRTMcsDNiilddi2I8HChCBDo+nbxwd9OiXESEwH0BN/67VnZKIUBtjU6HAQR8fP78hz50YkspIUp2VgFF/sl9wIREPGyTrl9wvJ0AAAEAeP/rBJ4FxgA4AB1ADR0eFzYEBA0jFwtyLQ0ALzMrMhE5LzMQzDIwMUEXBgYjIiQmNTU0NjYzMh4CFREUBgYjIi4CNRE3ERQWFjMyNjY1ETQuAiMiBgYVFRQWFjMyNgSUCjGAPLL+7ptdo2lSg10xdNGMaqx8Q+k7bUxCXTIPHSsdIjYfVaZ7PHYDH8MQGYftlhN2p1k1ZpRe/YaS0nBEfatoASEB/t5ReUI8eFgCiS1CLBQgRjkWWJJXEwAD/+EAAASrBcQAAwAWACkAHkAOEAkJHyYDchoYFgMDAhIAPzMRMzMzKzIyETMwMUERIxE3Ez4CMzIWFwcmJiMiBgYHAScDExcHAS4CIyIGByc2NjMyFhYCwvty1iFQYz8nQx8lBCYOFyYfDP7PpJPYI6b+0gwhJhYOJgQjHkInPGRUArf9SQK3KgIKUV4qDgy+AgQPIhv9UAEC+f3q4wECsBwhDwQCvQ0OJFwAAwAr/+sGYAQ6AAMAJABFACFAECYFAxwPLzwLcjwPAgMGcg8ALysyETkrMhEzETMzMDFBFSE1ITMeAhUUDgMjIi4CNTUzFRQeAjMyPgM1JgIlMwYCBxQeAzMyPgI1NTMVFA4CIyIuAzU0NjYGYPnLBG/uJkEoGzlchFlYjWM1rx42RyolNyYYCwRM/CHuO04DCxgmNyQqSDUesDVjjllYg105GyhCBDqysj6dvHBfrpNsPESEwH3U4lZ2SiEpSmN0PocBBHx8/vyHPnRiSykhSnZW4tR9wIREPGyTrl9wvJ0AAAMAJP/xBbsFsAAbAB8AIwAhQBEfIxgFBQ4iIx4IciMCcg4JcgArKysRMxI5LzMRMzAxQTU+AjMyFhYVFA4CIycyPgI3NCYmIyIGBhMRIxEhFSE1Ajg2gIM4oe6DPH7JjwFWbj0XAUOAXkN4ci36Auv7kwJuyhMfE2bLll6kfEe9KkhcMVJ0Pg8eAyz6UAWwyMgAAgBn/+wE7gXEAAMALAAdQA4DAgIJHRkUA3IpBAkJcgArzDMrzDMSOS8zMDFBFSE1ATMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4DMzI2NgNZ/a4C6vwMifawh9mZUlOc3Imv74YP+wpDgWpVgVcsGjNQbUZrhUUDQMfH/pqP4H9gtP6deJ3+tWGA4pNfh0dBfbV0elmWeVUsRIQAAAMALQAACDgFsAARABUALgAnQBMkISEJLhYWAAoJCHIUFRUjAAJyACsyMhEzKzISOS8zETMRMzAxQTMDDgQjIzU3PgQ3ARUhNQEhMhYWFRQOAiMhETMRITI2NjU0JiYjIQFk+iMIJ0VokWFAJzVNNyMVBQMA/UwDJgFuput9R4fDff3l+wEgX3s6Ontf/pIFsP0tn/KsbTPHAwQrVYjEgwKTyMj97njShWSpfUUFsPsXTHlFQ3hLAAADAJkAAAhCBbAAAwAHACAAI0ARCCAgAwICBhUHAnIWExMGCHIAKzIRMysyETkvMzMvMzAxQRUhNRMRIxEBITIWFhUUDgIjIREzESEyNjY1NCYmIyEEVP0BPvoELgFtput9R4jCff3l+gEhX3s6Ontf/pMDQcbGAm/6UAWw/dR0yINjpXpDBbD7G0dzQkFwRQADAC0AAAXDBbAAFQAZAB0AHUAOGQEYBhERGBwdAnIYCHIAKysyETkvMxEzMjAxYSMRNCYmIyIOAgc1PgMzMhYWFQERIxEhFSE1BcP6P39fLmZoYCgoXGVoM6Xwgvzb+wLq+6ABxGd0MAgPFQ3IDBUPCF/NpgPs+lAFsMjIAAACAI/+mQULBbAABwALABdACwkGAQJyCwMDAAhyACsyEjkrMi8wMXMRMxEhETMRJREjEY/7Aob7/kr7BbD7FwTp+lC7/d4CIgACAJAAAAS6BbAABQAeACFAEAYeHgQCExMFAnIUEREECHIAKzIRMysyETMROS8zMDFBFSERIxETITIWFhUUDgIjIREzESEyNjY1NCYmIyEEL/1b+q4BbqbsfEaIw3395PwBIF96Ozt6X/6SBbDI+xgFsP3Rb8iFZKZ5QgWw+xdHdEVDbkIAAAYAJv6aBdQFsAADAAcACwAPABMAJQAnQBMLEREgAwMHHghyDg8PEBQCcgkFAC8zKzIyETMrMjIRMzIRMzAxZRUhNTMRIwMhAyMRAxUhNSERIxEhMwMOBQcjNTM+AzcFEvvPPvAJBa4P7Hf9YANg+v1o+yMIKjtKVFcqhkEbQj8wCcfHx/3TAi391AIsBOnIyPpQBbD9sozgsYdiRRfHGV+b5qIABQAVAAAHogWwAAUACQANABMAFwAnQBMWEQkDAwAADw8UDAgIcg4KAQJyACsyMisyMjIvMxEzETMzMzAxQQEhASEHJwEhAQERIxEhASEnIQETATcBAk795QExAWMBBiPf/oL+yAH7Ak76BCH96f6pIwEBAV4X/oi8AfQCdgM6/Z/ZIP1qA0ACcPpQBbD8xtkCYfpQApaq/MAAAAIASf/sBIIFxAAeAD4AI0ARACACAj4+FTQwKglyDwsVA3IAKzLMK8wzEjkvMxI5OTAxQSM1MzI2NjU0JiYjIgYGFSM0PgIzMh4CFRQOAiUzMh4CFRQOAiMiLgI1MxQWFjMyNjY1NC4CIyMCh8quXXQ1O3pgSHZF+1GNuWd4woxKRYCz/snKebyCRFGUyXhhvZlc/Ed9U1+FRyVIakWuArqPN2NCO2I7NF5AX5dqOTVom2ZLhGQ5VzJgjVtmn244MWegcD5nPTxoQT5bORwAAQCSAAAFDQWwAAkAF0ALBQAGAggCcgQGCHIAKzIrMhI5OTAxQQEzESMRASMRMwGMAob7+/16+voBmQQX+lAEGPvoBbAAAAMALAAABQ8FsAADAAcAGQAZQAwSBREIcgIDAwQIAnIAKzIyETMrMjIwMUEVITUhESMRITMDDgQjIzU3PgQ3BE/9RgN6+/1P+SMHKERokWFAJzVNNiQVBQWwyMj6UAWw/S2f8qxtM8cDBCtViMSDAAACADL/6wThBbAAEwAYABpADhcWABUECAIYAnIPCAlyACsyKzISFzkwMUEBIQEOAyMiJic3FhYzMjY2NwMBEwcBAloBcgEV/gYYPVZ6VxdBDwIMOQ06RCkQywFuSMP9+wH7A7X7WDdnUC8EAsUCAidDKARs/Nr++gcEMwAAAwBO/8QGGAXsABUAKQAtABtADB8MDCsWAAArKgNyKwAvKxE5LzMROS8zMDFBITIeAhUUDgIjISIuAjU0PgIXIgYGFRQeAjMhMjY2NTQuAiMDESMRAqQBHoHZolpaotmB/uKA2qNZWaPagHCiVzJehlMBIG+gVzFdhFQY8QUnVp3bhoTanVRUnNmEhtufVshfsn1ckGQ2X7B5XZNmNgGN+dgGKAACAI7+oQW9BbAABQANABlADAwHAnIFBAQJBghyAQAvKzIyETMrMjAxZQMjESM1BREzESERMxEFvRPngvxN/AKF/Mn92AFfyckFsPsXBOn6UAAAAgCRAAAE7QWwABUAGQAXQAsXBhERGAACchgIcgArKxE5LzMyMDFTMxEUFhYzMj4CNxUOAyMiJiY1ATMRI5H7Pn9fLmZnYCgnXWRoM6XwggNh+/sFsP49Z3UwCA8VDccMFg8IX86mAcP6UAAAAQCVAAAHBQWwAAsAGUAMBQkGAgILAAJyCwhyACsrETMRMzIyMDFTMxEhETMRIREzESGV/AHC+gG++vmQBbD7FwTp+xcE6fpQAAACAJX+oQexBbAABQARAB1ADgwFCAgEEQhyDwsGAnIBAC8rMjIrMjIRMzMwMWUDIxEjNQEzESERMxEhETMRIQexE92C+lb8AcL6Ab76+ZC//eIBX78E8fsXBOn7FwTp+lAAAAIAFQAABdYFsAADABwAHUAOERIPBBwcDwABAnIPCHIAKysyETkvMxEzMjAxUzUhFRMhMhYWFRQOAiMhETMRITI2NjU0JiYjIRUB7FgBbqbrfkiIw3z95fsBIF96Ozt6X/6SBPDAwP6Rb8iFZKZ5QgWw+xdHdEVDbkIAAgCZAAAGVAWwABgAHAAdQA4aGQ4LABgYCwwCcgsIcgArKxE5LzMRMzIzMDFBITIWFhUUDgIjIREzESEyNjY1NCYmIyEBESMRAUYBb6brfUeIw3z95PsBIV96Ozt6X/6RBQ77A4FvyIVkpnlCBbD7F0d0RUNuQgL2+lAFsAAAAQCQAAAEugWwABgAGUAMDgsAGBgLDAJyCwhyACsrETkvMxEzMDFBITIWFhUUDgIjIREzESEyNjY1NCYmIyEBPgFupux8RojDff3k/AEgX3o7O3pf/pIDgW/IhWSmeUIFsPsXR3RFQ25CAAIAY//sBOgFxAADACwAHUAOAwICHgkFKQlyGRUeA3IAKzLMK8wzEjkvMzAxQRUhNQEzHgIzMj4CNTU0LgMjIgYGByM+AjMyHgIVFRQOAiMiJiYEUP2f/nX6C0WFbFd/UigcOVNuRGmCQgv6D4bvronbnFNRmtiGsfWIAzvIyP6fYIRERoGzb3pdmXZRKkeHX5PigGG1/p14nf60YH/gAAAEAKH/7AcMBcQAAwAHAB0AMwAjQBMvBwYGDiQZAwJyAghyGQNyDglyACsrKysRMxI5LzMyMDFBESMRARUhNQUVFAIGBiMiJiYCNTU0EjY2MzIWFhIHNTQuAiMiDgIVFRQeAjMyPgIBnPsCK/6KBbZWoN2Ihd6iWFig3oWI3qBX+zBahFRSglswMF2CUlWCWi8FsPpQBbD9ccDAIVCl/vq4YWG4AQalUKUBBblhYbn++/VSert/QUF/u3pSeryBQUGBvAAAAgAXAAAEWAWwABYAGgAfQA8XFhYAAAkMDBkIcg4JAnIAKzIrMhESOS8zEjkwMUEhJyYmNTQ2NjMhESMRIyIGFRQWFjMhBQEhAQOp/m9jpbCA7aIB6fztjIg9eVoBPv7O/q7+8gFWAiIpNNShkMZm+lAE6Ih4UnU/UP1uApIAAwBa/+sEPwYUABYALwBEABlADDoiMBcXIgABciILcgArKxE5LzMRMzAxQTMUDgIHDgMXFQc1NBI2Njc+AgMyHgIVFRQOAiMiLgI1NSY2Njc+AhciBgYVFRQeAjMyPgI1NTQuAgMjwzFfi1tUh1soCL9GgbNuS2QxqWyodD1CgLl3drqAQgEZJA4yiK89WnE1Hj1jREVhPR0dPmIGFFlzSSwSEk2J1ppEEUS/ARzDdBYQITX+F0uGtmsWcL6NT1KTxnUWFSguHmWYVr9VjFIWQ3hbNDRbeEMWPm5VMgAAAgCPAAAEOAQ6ABsAMwAtQBYCARsrKSkoASgBKA8NEAZyHh0dDwpyACsyETMrMhE5OS8vETMSOTkRMzAxQSEnITI2NjU0LgIjIxEjESEyHgIVFA4CBwMhNyEyNjY1NCYmIyE3IRceAhUUDgICiv6mAgEcRlssGjVPNMXxAbZop3Y/K1R6Tzf+YGABQEBUKShTQv7tAgFHRWeIRDlvoAHPqhw5KSIzIQ/8hAQ6JEpxTDJYRCsF/e++ID0qKz4hqkIHSnBCTHRNJwABAIMAAANMBDoABQAOtgIFBnIECnIAKysyMDFBFSERIxEDTP4o8QQ6wPyGBDoAAwAn/r4EwgQ6AA8AFQAdACFAEB0YCRYWGxMICnIVEBAABnIAKzIRMysyMjIRMy8zMDFBMwMOAwcjNTc+AzcTIREjESEBIREjESERIwFA8QwFQmqFSUciKz8sGQRMAq7w/kL+qASa8f1L9QQ6/oOm7qNoHr4CLl1xmGkBffvGA279Uv3+AUL+vgAABQAgAAAGawQ6AAUACQANABMAFwAwQBcVEBAAFhERCQMDBgAAFAcMEhMNDQIGcgArMhEzPzMzOS8zMxEzMxEzETMRMzAxQQEhEzMHJwEhAQERIxEhASEnMxMTATcBAeP+UAEo/NMfrv7r/tgBiAIT8AOL/lD+1yDU/BP+6rsBhgG1AoX+Vtsj/igCYQHZ+8YEOv172wGq+8YB2In9nwACAE7/7APHBE0AHQA7ACNAEQAfAgI7OxQyLikLcg8LFAdyACsyzCvMMxI5LzMSOTkwMUEjNTMyNjY1NCYmIyIGBhUjNDY2MzIeAhUUDgIlMzIeAhUUDgIjIiYmNTMUFhYzMjY2NTQmJiMjAjzQqEBNISFOQzdXMvFzwnRjnm87NGKL/trQYJRkM0F3pGNsy4PxMl5CRFYqKlZBqAIFeiI9KSRBKiRAKmWSTilPdU03YksqRiVIaURMeVQsSJd1KUgtK0coNkIfAAEAhAAABA8EOgAJABdACwUABgIIBnIEBgpyACsyKzISOTkwMUEBMxEjEQEjETMBdQGp8fH+V/HxAWAC2vvGAtv9JQQ6AAADAI8AAARlBDoAAwAJAA0AH0APDAcHCwYGAgkDBnIKAgpyACsyKzIROS8zMxEzMDFBESMRIQEhJzMBEwE3AQGA8QOz/hn+7SDJASQT/rq+AcUEOvvGBDr9ddoBsfvGAdiJ/Z8AAwAgAAAEEAQ6AAMABwAZABlADBIFEQpyAgMDBAgGcgArMjIRMysyMjAxQRUhNSERIxEhMwMOBCMjJzc+BDcDU/3wAs3x/enuHQYjOlRwRksBJiU2JxkPBAQ6wMD7xgQ6/el3tYFQJsYDAyE+YoZZAAMAjwAABXAEOgAGAAoADgAbQA0ACQwGAQoGcgsDCQpyACsyMisyMjISOTAxQQEzASMBMyMRIxEBETMRAv8BQtH+P6T+QNE+8QPv8gEkAxb7xgQ6+8YEOvvGBDr7xgADAIQAAAQNBDoAAwAHAAsAG0ANCQYIAwICBgcGcgYKcgArKxE5LzMyETMwMUEVITUTESMRIREjEQNf/dBG8QOJ8QJ2vr4BxPvGBDr7xgQ6AAMAhAAABA8EOgADAAcACwAZQAwJBggCAwMHBnIGCnIAKysyETMyETMwMUEVITUzESMRIREjEQNS/eo58QOL8gQ6wMD7xgQ6+8YEOgACACMAAAPVBDoAAwAHABC3AwYHBnICCnIAKysyMjAxQREjESEVITUCcvICVfxOBDr7xgQ6vr4AAAUAU/5gBYEGAAAWACsAQgBWAFoAJ0AVJwYGSR4REVIzPgtyMwdyWAByVw5yACsrKysRMzMRMzIyETMwMUEVFA4CIyIuAicRPgMzMh4DBzU0LgMjIgYGBxEeAjMyPgIlNTQ+AzMyHgIXEQ4DIyIuAjcVFB4CMzI2NjcRLgIjIg4CAREzEQWBM2STYVV+VjQMDDNXfFVOfmBAIfEQITRJMEFVKwYHLVRBPFM1GPvDIEFgfk5UelUzDAs0VHxVYJRkM/EXMlI8QlQtBwYsVEI8UzMXASjyAhAVc8GOTjppj1YBOVyZcD03ZY2wehU/cl9HJytNMv5WKkAlM1x6RxVlsI1lNz1wmVz+01iUbDxOjsGIFUd6WzQoRi0BnjJNKzxpi/wCB6D4YAAAAgCE/r8EogQ6AAcADQAbQA0GAQMNDAwACnIBBnIJAC8rKzIRMzIRMzAxcxEzESERMxE3AyMRIzWE8QGo8pMT3YIEOvyGA3r7xr/+AAFBvwACAGAAAAPhBDsAAwAXABdACw8UCQkBAAZyAQpyACsrETkvMzIwMUERIxETFQ4CIyImJjURMxEUFhYzMjY2A+HxiyxteD2Pz2/wMWJKPm5sBDr7xgQ6/iG/Ex8TWLeNAUj+uFFgKhEeAAEAhAAABgYEOgALABlADAUJBgICCwAGcgsKcgArKxEzETMyMjAxUzMRIREzESERMxEhhPEBV/MBVvH6fgQ6/IYDevyGA3r7xgAAAgB9/r8GuwQ6AAUAEQAdQA4MBQgIBBEKcg8LBgZyAQAvKzIyKzIyETMzMDFlAyMRIzUBMxEhETMRIREzESEGuxPdgvs08QFY8gFX8fp9v/4AAUG/A3v8hgN6/IYDevvGAAACACAAAATxBDoAAwAcAB1ADhESDxwEBA8CAwZyDwpyACsrMhE5LzMRMzIwMUEVITUBITIWFhUUDgIjIREzETMyNjY1NCYmIyECKv32AdwBPo3DZzpwpGn+IfLtSFYnJ1ZI/sIEOsDA/qhep2tPh2Q4BDr8hTJQLS5SNAAAAgCPAAAFzwQ6ABgAHAAdQA4aGQ4LGAAACwwGcgsKcgArKxE5LzMRMzIzMDFBITIWFhUUDgIjIREzETMyNjY1NCYmIyEBESMRAS8BP4zEZzpxo2n+IfLtSFYnJ1ZI/sEEoPEC4l6na0+HZDgEOvyFMlAtLlI0Ahj7xgQ6AAEAjwAABCUEOgAYABlADA4LGAAACwwGcgsKcgArKxE5LzMRMzAxQSEyFhYVFA4CIyERMxEzMjY2NTQmJiMhAS8BP4zEZzpxo2n+IfLtSFYnJ1ZI/sEC4l6na0+HZDgEOvyFMlAtLlI0AAACAFD/6wPoBE4AJwArAB1ADisqKgkdGRQLcgQACQdyACsyzCvMMxI5LzMwMUEiBgYVIzQ2NjMyHgIVFRQOAiMiJiY1MxQWFjMyPgI1NTQuAgEVITUCADhdN+R3xHV3tnw/QHy1dn7Eb+Q0XD1DXjoaGjlfAQ7+SQOOL1M4aqtlVZbFcCNwxJdVaLd5PWI5PGR/QSNDfmQ7/uijowAEAJL/7AY2BE4AAwAHAB0AMwAjQBMkAwICGS8OBwZyBgpyDgdyGQtyACsrKysRMxI5LzMyMDFBFSE1ExEjEQE1ND4CMzIeAhUVFA4CIyIuAjcVFB4CMzI+AjU1NC4CIyIOAgL5/bzO8QG1RIK6dni7gkREgbt3d7qDRPIeQGRERGNAHx9AZEVDY0AeAoXAwAG1+8YEOv3XF3XJlVNTlcl1F3XIlVNTlciMF0mCYjg4YoJJF0iBZDk5ZIEAAAIALgAAA+AEOgADAB0AHUAOARISExMDCQQGcgcDCnIAKzIrMhI5LzMSOTAxQTMBIwEhESMRIyIGBhUUFhYzIRUhIi4CNTQ+AgFg+v7N+QHiAdDw4ERYKidTPwE+/sJknm46PHGjAhH97wQ6+8YDfC9LJydILrAzW3tJS35eMwAABP/X/ksD+gYAABEAFQAsADAAHUAQMC8oHAdyFQByFApyDQYPcgArMisrKzLMMjAxQTMRFAYGIyImJzcWFjMyNjY1AREjERMnPgMzMh4CFREjETQmJiMiDgIBFSE1AwjyVZ5vIz4iDhM7Fik6Hv5i8MZOAT1vnF9QgV4x8i1WPkFjQiEBN/1gAc799HmoVgcKuwYGK1I6Bj76AAYA/EUBcL6NTSxhm2/9SQK5TlwpNFp2As6mpgACAFL/7AP1BE4AAwArABtADQQNAwICDSEYB3INC3IAKysyETkvMxEzMDFBFSE1ATI2NjczDgIjIi4CNTU0PgIzMhYWFyMuAiMiDgIVFRQeAgKl/igBbTtfOwPjA3jFeHy5ejw8e7h7gcVwA+MDNV9CSWE2FhY3YAJoo6P+RC9UN2msZVWWxHAjcMWWVWe3eTxhOjtlfUMjQ35jOwADAB0AAAafBDoAEQAVAC4AJUASFi4uACQhIQoJCnIUFRUjAAZyACsyMhEzKzIyETMROS8zMDFBMwMOBCMjJzc+BDcBFSE1ASEyFhYVFA4CIyERMxEzMjY2NTQmJiMhAQXuHQYiO1RvR0sBJyQ2JhoQAwJN/f8CbQE+jcRmOnCjav4i8e1JVicnVkn+wgQ6/el3tYFQJsYDAyE+YoZZAc7AwP6HWp5mTIJgNQQ6/IQxTCopSCwAAAMAhAAABrIEOgADAAcAIAAlQBIVFhMTBggDIAMCAgYHBnIGCnIAKysROS8zMxEzETMRMzIwMUEVITUTESMRASEyFhYVFA4CIyERMxEzMjY2NTQmJiMhA1/90EbxAzcBP43EZzpxpGn+IvHtSFcnJ1dI/sECnL6+AZ77xgQ6/odanmZMgmA1BDr8hDFMKilILAAAA//oAAAD+gYAAAMAGgAeABlADR4dFgoHcgMAchECCnIAKzIrKzLMMjAxQREjERMnPgMzMh4CFREjETQmJiMiDgIBFSE1AWrwxk4BPW+cX1CBXjHyLVY+QWNCIQFI/WAGAPoABgD8RQFwvo1NLGGbb/1JArlOXCk0WnYC16enAAACAIT+mwQPBDoAAwALABdACwAGBgsKcgkEBnICAC8rMisyEjkwMWUzESMBMxEhETMRIQHS8vL+svEBqPL8dcD92wWf/IYDevvGAAIAiP/rBs8FsAAYADAAG0AOLB8JchQHCXImGg4AAnIAKzIyMisyKzIwMUEzERQOAiMiLgI1ETMRFB4CMzI2NjUBMxEUBgYjIi4CNREzERQeAjMyNjY1Ay3LP3OaXWKme0T7HjZLLUNjOAKn+3nQhlmZcD/MHzlOLz9gNQWw/ABwqnI5OXKqcAQA/ABBYD8eN3BXBAD8AJXKZjlyqnAEAPwAQWA/HjdwVwAAAgBy/+sGAwQ6ABgAMQAbQA4sHwtyFAcLciYaDgAGcgArMjIyKzIrMjAxQTMRFA4CIyIuAjURMxEUHgIzMjY2NQEzERQGBiMiLgI1ETMRFB4CMzI+AjUCxMQ5Z45UWJRsPPIXKzslOVUwAk7xart3U4ljNsQYLkIpJkAtGAQ6/Vdpnmo1NWqeaQKp/Vc7VzgcMWZPAqn9V4y7XzVqnmkCqf1XO1c4HBw4VzsAAAL/4QAABCMGFwAXABsAIUAQDQoAFxcKGhsbCgsBcgoKcgArKxE5LzMROS8zETMwMUEhMhYWFRQGBiMhETMRMzI2NjU0JiYjIQEVITUBLgE+jcRmZsSN/iLy7EhXJydXSP7CAW/9RAMAY6tvb69lBhf6qDZYMjBZOQKgp6cAAAMAmP/tBtMFxQADACwAMAAgQBEDAgIvMAJyLwgdFANyKQkJcgArMisyPysSOS8zMDFBFSE1ATMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4DMzI2NgERIxEFKPwTBJ36DIn1sYfYmVJTnNyIrvGGDvsJQ4JqVIFWKxkzTm1Ga4VG+8b7A07AwP6Nj9+AYbP+nXmd/rVggOKSXoZHQHy1dHtYl3dULUSDBDT6UAWwAAADAIb/7AW6BE4AAwArAC8AJEATAwICLi8Gci4KIR0YB3IIBA0LcgArMswrzDM/KxI5LzMwMUEVITUBMjY2NzMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4CAREjEQSC/JYC5ztgOgPjA3jFeHy5ejw8e7d8gsRwA+MDNV9CSWA2FxY3YP3C8QJxp6f+Oy9UN2msZVWWxHAjcMWWVWe3eTxhOjtlfUMjQ35jOwOO+8YEOgAEABoAAAUbBbAABAAJAA0AEQAkQBERDQwMAgAGBgcDAnIPBQUCCAA/MxEzKzIyETMROS8zMzAxQQEhATMBATczAQEVITUFESMRAtv+RP77AgaTAWP+RiySAgH+6f0WAerdBSP63QWw+lAFK4X6UAJmuLhK/eQCHAAEAAsAAARHBDoABAAJAA0AEQAeQA4RDQwMAQcDBnIQBQUBCgA/MxEzKzISOS8zMzAxQQEjATMTAQMzAQMVITUFESMRAgv+9/cBqbXo/vJbtgGpzP1kAaW5As39MwQ6+8YCzQFt+8YBxampQP57AYUABgCsAAAHNQWwAAMACAANABEAFQAZADRAGgkUFAYGGBURERAQAwICGAgWAnIECgoLBwJyACsyMhEzKz85LzMzETMRMxEzETMRMzAxQRUhNQEBIQEzAQE3MwEBFSE1BREjEQERIxEDh/2/A6/+RP77AgeSAWP+RiySAgH+6f0WAenc/Wb7Ama3twK9+t0FsPpQBSuF+lACZri4Sv3kAhwDlPpQBbAAAAYAmgAABh0EOgADAAgADQARABUAGQAuQBcVEREQEAMCAhgZBnIJFBQGBhgKCwcGcgArMj8zETMRMysSOS8zMxEzETMwMUEVITUBASMBMxMBAzMBAxUhNQURIxEBESMRAyT9wwL6/vf3Aam16P7yWrUBqcv9YwGluf3r8gHFqKgBCP0zBDr7xgLNAW37xgHFqalA/nsBhQK1+8YEOgAABQB+AAAGZwWwABYAGgAfACQAKAA0QBkZGhokGx8fIyMTKAYGExMBHCQCcg0nJwEIAD8zETMrMhI5LzMRMxEzETMRMxEzETMwMWEjETQ2NjMhMhYWFREjETQmJiMhIgYVARUhNQEBIQEjAQEHIwEBESMRAXn7e+aiAeOi53r6OnVa/h2FgwOT/O8BQgGdARb+AJP+yQGgJJL9/wLq+gFhpsZYWMam/p8BYWJtLWmTBE/Jyf0KAvb8lwNp/QNsA2n9Ufz/AwEABQCBAAAFXQQ7ABcAGwAgACUAKQAwQBcaGxslICQkEykGBhMTAR0lBnINKCgBCgA/MxEzKzISOS8zETMRMxEzETMRMzAxYSM1NDY2MyEyFhYVFSM1NCYmIyEiBgYVARUhNQEBIQEjAwEHIwEBESMRAXLxbtCRAT6Qz3DyMGJL/sJLYzAC/P0vASABLAEI/m+H1wEwH4f+bgJx8a6fv1VVv5+urmFtLCxtYQONq6v9ugJF/VoCpv21WwKm/ez92gImAAAHAKUAAAisBbAAAwAHAB4AIgAnACwAMAA8QB4hIiIkLAJyJysrGzAODhsbAwICBQcCchUvLwkJBQgAPzMRMxEzKxI5LzMzETMRMxEzETMrMjIRMzAxQRUhNRMRIxEBIxE0NjYzITIWFhURIxE0JiYjISIGFQEVITUBASEBIwEBByMBAREjEQUC/FFN+wMZ+nrnoQHkouZ6+jp1Wf4chYMDlPzuAUIBngEW/f6R/sgBoSWR/f8C6foDJ8DAAon6UAWw+lABYabGWFjHpf6fAWFibS1pkwRPycn9CgL2/JcDaf0DbANp/VH8/wMBAAcAkAAAB24EOwADAAcAHwAjACgALQAxAD5AHiUiIyMtLQcoLCwbMQ4OGxsDAgIGBwZyFTAwCQkGCgA/MxEzETMrEjkvMzMRMxEzETMRMxEzETMRMzMwMUEVITUTESMRASM1NDY2MyEyFhYVFSM1NCYmIyEiBgYVARUhNQEBIQEjAwEHIwEBESMRBM/8IZHxAvPxbtCRAT6Qz3DyMGJL/sJLYzAC/P0vASABLAEI/m+H1gEwIIf+bgJx8QJhtbUB2fvGBDr7xq6fv1VVv5+urmFsLS1sYQONq6v9ugJF/VoCpv21WwKm/ez92gImAAADACj+RAOxB4cAFwBAAEkAK0AUGA0MQEAAKywJRUNDQkhBgEcXAAIAPzLeGs0yOTIRMz8zEjkvMzMzMDFTITIeAhUUDgIjIzUzMjY2NTQmJiMhEzMyHgIVFA4CIyMiBhUUFhYXBy4CJzQ2NjMzMj4CNTQuAiMjExc3MxUBIwE1fwEZcLiFSUiEuXGXkl90NjdzWv7ngpKByYxISYS1bTlFPTVIHE5WhU4BVZpqOD1iRCMoTHJKjm2Vls/+55f+6AWwMWGRX1WHXzOMN2E+Olw1/iQyYI1bZp9tOTouMUMqDZUYYIpXXnk7Ij1UMT1cPh8E/p2dC/7rARYKAAADADL+TAOJBhsAGABBAEoAJkARDRkMQUEALUNJRkRCgEgYAAYAPzLeGs0yMjI5LxI5LzMzMzAxUyEyHgIVFA4CIyM1MzI2NjU0LgIjIRMzMh4CFRQOAiMjIgYVFBYWFwcuAic0NjYzMzI+AjU0LgIjIxMXNzMVASMBNX0BFmirfURCealon5tQYiwbN1Y6/up/m3e5gEJBeadjMUw/MkQaTUl/UQFRk2QyN1g9ICJDYT+XQpWWz/7omP7oBDomTXJKQWhKJ30lQisdMSMU/r0kRmZCTHhULDouMUMqDY0aXoZTWXI4Fic2ICY4JhMEUZ2dC/7rARYKAAMAYP/sBRkFxAAXACgAOQAfQBIMKWoyIGoyMgwAGGoAA3IMCXIAKysrEjkvKyswMUEyHgMVFRQCBgYjIi4DNTU0EjY2FyIOAgcGBhUhJiYnLgMDMj4CNzY2NSEWFhceAwK8bLuUajhWoN2IarqVbDlYod6FSHlZOQkBAgLAAQECCTdZeUlMelg2CAEB/UEBAgEKOFp5BcQ/eKzdhFCl/vq4YT93rd2EUKUBBblhzTRllmIOHxAPHw5jlWY0+8E1appkCxcLDxwNYpZmNAAAAwBN/+wEOwROABUAIAArAB9AEgshaicbaicnCwAWagAHcgsLcgArKysSOS8rKzAxQTIeAhUVFA4CIyIuAjU1ND4CFyIOAgchLgMDMj4CNyEeAwJDd7yBRESBund3u4JERIG7djtbPyUHAgQGJkBbOjtbPyYG/fwGJUBcBE5Tlcl1F3XIlVNTlch1F3XJlVPALE5oOztoTiz9HitPaD09aE8rAAACABAAAAT1BcMADgATABlADQ4SCAUTAnIFA3ISCHIAKysrETMRMzAxQRM+AjMXByMiBgYHASMBARMjAQKT5yJaflgpARYfMSYO/py8/uIBRFq8/hIBfAMFbI9HAdIdOSz7kgWw+87+ggWwAAACAB4AAAQaBE4AEgAXABVACxcGchIWCnIMBQdyACsyKzIrMDFBEz4CMzIWFwcmJiMiBgYHASMDExMjAQIKex5WckYdNBgXBB4OFyshCv76oqbGTKL+lgFsAcJifz8HDrwCBBksHfzfBDr9Mv6UBDoABABg/3YFGQYuAAMABwAfADcAJEAQAgInJwMaA3IHBzMzBg4JcgArzTMRM3wvKxjNMxEzfS8wMUERIxETESMRARUUAgYGIyIuAzU1NBI2NjMyHgMHNTQuAyMiDgIVFRQeAzMyPgIDG7y9vAK5VqDdiGq6lWw5WKHehWy7lGo4/B47VW9EUoJbMSA8Vm9BVYJaLgYu/lkBp/r4/lABsAHaUKX++rhhP3et3YRQpQEFuWE/eKzd1FJhn3lSKkF/u3pSYp96UypBgbwAAAQATv+GBDwEtQADAAcAHQAzACRAEAcHJCQGGQtyAgIvLwMOB3IAK80zETN9LysYzTMRM3wvMDFBESMRExEjESU1ND4CMzIeAhUVFA4CIyIuAjcVFB4CMzI+AjU1NC4CIyIOAgKbrKms/mJEgbt2d7uCRESCunZ3u4JE8R5AZEVDY0AfH0FjRERjQB4Etf5oAZj8cP5hAZ/sF3XJlVNTlcl1F3XIlVNTlciMF0mCYjg4YoJJF0iBZDk5ZIEABACI/+sGwgc7ABUAIABBAGUAM0AZW04JclQxMSw4CXJCQ0MRCAgbGxYWIiECcgArMjJ8LzMYLzMRMzIRMysyMi8zKzIwMUEzFSMiLgIjIgYVFSM1NDYzMh4CASc2NjU1MxUUBgYlFSIGBhURFB4CMzI2NjURMxEUDgIjIi4CNRE0NjYFNTIeAhURFA4CIyIuAjURMxEUHgIzMj4CNRE0LgIFSxwdVotyYCwxPIF9bjptb3/+gE4hI6IxRv6xPFs1HjZLLUNjOMs/c5pdYqZ7RHfOAy5ip3pERHqnYlubcz/LIDpSMS1LNh8fNksGv4ImMCY0NhIkb2slMiX+VzgoSCZfZiZPQIjIO3le/e5GaEMhN3BXAYb+enCqcjk8d7F1AhKd0mvIyDx3snX97nWxdzw5cqpwAYb+ekFgPx4hQ2hGAhJGaEMhAAQAdf/rBeAF4gAVACAAQgBmADNAGVxPC3JVMjIsOQtyQ0REEQgIGxsWFiIhBnIAKzIyfC8zGC8zETMyETMrMjIvMysyMDFBMxUjIi4CIyIGFRUjNTQ2MzIeAgEnNjY1NTMVFAYGJRUiBgYVFRQeAjMyPgI1NTMVFA4CIyIuAjU1NDY2BTUyHgIVFRQOAiMiLgI1NTMVFB4CMzI+AjU1NC4CBN8eIFaLcWAsMD2BfW47a29//oRNISOhMUX+3zNPLBcqOSMoQS8auzZihVBWkms8bLwCo1qYcD47bJJXToVjNrsaL0EnIzsqFxkvQAVmgSUxJTM3EiRvayUyJf5VOChJJV9mJk5Be781bVXxP109HRw4VzvFxWmeajU3bqVs8ZHDYr+/N26kbfFspW43NWqeacXFO1c4HB09XT/xQF08HgADAIj/6wbPBxAABwAgADgAK0AVNCcJcgUCAQEHBy0hCAgVAnIcDwlyACsyKzIRMzMzfC8zGC8zMysyMDFBITUhFyEVIwczERQOAiMiLgI1ETMRFB4CMzI2NjUBMxEUBgYjIi4CNREzERQeAjMyNjY1A0/+twNRAv6jrSLLP3OaXWKme0T7HjZLLUNjOAKn+3nQhlmZcD/MHzlOLz9gNQaYeHh+avwAcKpyOTlyqnAEAPwAQWA/HjdwVwQA/ACVymY5cqpwBAD8AEFgPx43cFcAAwBy/+sGAwWxAAcAIAA5ACtAFTQnC3IFAgEBBwctIQgIFQZyHA8LcgArMisyETMzM3wvMxgvMzMrMjAxQSE1IRchFSMHMxEUDgIjIi4CNREzERQeAjMyNjY1ATMRFAYGIyIuAjURMxEUHgIzMj4CNQLf/scDMAX+sa0bxDlnjlRYlGw88hcrOyU5VTACTvFqu3dTiWM2xBguQikmQC0YBTl4eH+A/Vdpnmo1NWqeaQKp/Vc7VzgcMWZPAqn9V4y7XzVqnmkCqf1XO1c4HBw4VzsAAgBn/o4EsgXFACEAJQAZQAwWEg0DciUAACQBCXIAK80zETMrzDMwMWUVIi4DNRE0PgIzMhYWFyMuAiMiDgIVERQeAzMRIxEClWWtiWAzT5TOfqjxggH6AT9/Y0p0TikaM0pi2vqyxzptmLtrARCG4KVadN6fYoRDPnCWV/7uRn5nSyj93AIkAAIAXf6LA/QETgAfACMAGUAMFREMB3IgAAAiAQtyACvNMxEzK8wzMDFlFSIuAjU1ND4CMzIWFhUjNCYmIyIOAhUVFB4CMxEjEQJFd7Z8Pz98tnZ+xG7jM1w+RF45Gxs4YNnxq8BVlsVwI3DFllVnt3k8Yjk7ZX1DI0N+ZDv94AIgAAABAHAAAASQBT4AEwAIsQ8FAC8vMDFBAwUHJQMjEyU3BRMlNwUTMwMFBwMmzgEhRv7dtavh/t9FASXM/t5HASO7qOYBJUoDKv6WrH6q/sABjqt9qwFrq3+rAUn+aqt9AAAB/HAEpf83BfwABwAVtwYGBAQBAgIBAC8zLxEzETN8LzAxQyEVJzchJxfJ/eOqAQIeAakFI34B6mwBAAAB/HUFF/9rBhUAFQAStgEUFA8GgAsALxrMMjMRMzAxQTMyPgIzMhYVFSM1NCYjIg4CIyP8dR5QgXFtO29/gzwzLGFzjVcgBZklMiVrbyQSNzMlMSUAAAH9gQUZ/nMGYgAFAAqyAIACAC8azTAxQSc1MwcX/iSjuAE7BRnDhpdwAAH9pgUZ/pcGYgAFAAqyAYAEAC8azTAxQQcnNycz/pejTjoBuAXcw0JwlwAACPom/sQBwgWvAA0AGwApADcARQBTAGEAbwAAQSM0NjMyFhUjNCYjIgYBIzQ2MzIWFSM0JiMiBhMjNDYzMhYVIzQmIyIGAyM0NjMyFhUjNCYjIgYBIzQ2MzIWFSM0JiMiBgEjNDYzMhYVIzQmIyIGAyM0NjMyFhUjNCYjIgYTIzQ2MzIWFSM0JiMiBv2EcXFhYnFwLTY1LAJQcnFhYnJxLDc0LLpxcWFicXAsNzQtxXFxYWJxcCw3NC39wHFxYWJxcC02NC39v3JyYWJxcC02NSyxcXFhYnFwLDc0LadycWFicnEsNzQsBPNTaWlTKD09/sNTaWlTKD09/eFTaWlTKD09/dFTaWlTKD09/rxTaWlTKD09BPJTaWlTKD09/eFTaWlTKD09/dFTaWlTKD09AAj6Uf5jAZIFxgAEAAkADgATABgAHQAiACcAAEUzFwMjEyMnEzMBNTcFFSUVByU1ASc3JRcBFwcFJwEHJwM3ATcXEwf9y4kLemCUiAx6YAHZDQFN+hkN/rMFV2ECAUJE+2thAv7ARQFdYhGUQQPFYhGVQjwO/q0GAw4BUvwmiwx8YpeLDHxiAQRjEJlE/CljEZlFBA5iAgFGRftVYwL+u0cA//8Akv6ABdcHJQQmANwAAAAnAKEBGQE+AQcAEAR5/8gAFUAOAiMEAACYVgEPAQEBXlYAKzQrNAD//wCE/oAE2gXaBCYA8AAAACcAoQCS//MBBwAQA3z/yAAVQA4CIwQBAJhWAQ8BAQF9VgArNCs0AAAC/+EAAAQjBmAAFwAbABpADBoLGwJyABcXDQ0KEgA/MxEzLzMrzjMwMUEhMhYWFRQGBiMhETMRMzI2NjU0JiYjIQEVITUBLgE+jcRmZsSN/iLy7EhXJydXSP7CAW/9RAMAY6tvb69lBmD6XzZYMjBZOQNvpqYAAgCUAAAEzwWwAAMAGwAjQBEBAgUAAwYGBQUSEBMCchIIcgArKzIROS8zETMzETMzMDFBAQcBAyE1ITI2NjU0JiYjIREjESEyFhYVFAYGAzcBlmn+bBP+hQF7Y3o5OXpj/tH6Aimp7H187QPe/kFfAb7+ocdAcUlFeUr7GAWwd9GGjcpsAAAEAH3+YAQvBE4AAwAIAB4ANAAlQBQAAzABAjAlGg8LcgcGchoHcgYOcgArKysrETMyMjIRMzMwMUEBBwEDESMRMwEVFA4CIyIuAic1PgMzMh4CBzU0LgIjIg4CBxUeAzMyPgICvwFnaf6Y5/HeAtQ3a5xmZZdoPw0NP2iWZGaebDbxHDxdQUBcPiIHCSQ9W0BBXDscAar+Xl8BogIf+vYF2v3tFXbJlVJLirtwUXfCjExPkcuRFUuBYjcrTGU7wjdfSCk4Y4IAAAIAjwAABDcHEwADAAkAFUAKAgYGAwkCcggIcgArK84zETMwMUERIxETFSERIxEEN/Hp/Vv7BxP93gIi/p3I+xgFsAAAAgB9AAADYAV3AAMACQAVQAoCBgYDCQZyCApyACsrzjMRMzAxQREjERMVIREjEQNg8tn+J/EFd/4DAf3+w8D8hgQ6AAACAJn+xQSaBbAABQAdABlADAYHBxMSAgUCcgQIcgArKzIvMzkvMzAxQRUhESMREzUzMh4CFRQOAiM1Mj4CNS4DIwQ3/Vz6q/6K3Z1UOnvDiVNqOxgBLlqGWAWwyPsYBbD8zcZLlNmOd86cV7c/bIdHYpJjMQAAAgB9/uMD3QQ6ABQAGgAbQA0AAQELFxoGchkKcgwLAC8zKysyETkvMzAxUzUzMhYWFRQOAgcnPgInNiYmIwEVIREjEc3ynvWLKVuPZllPYy8BAUyGWwGI/ifxAcrGb9WeOYmFaRupG1NwRF5+QAJwwPyGBDoA//8AFf6aCAwFsAQmANoAAAEHAmwGuQAAAAu2BRsMAACaVgArNAD//wAg/poGxAQ6BCYA7gAAAQcCbAVxAAAAC7YFGwwAAJpWACs0AP//AJn+mAV/BbAEJgJHAAAABwJsBCz//v//AI/+mgTBBDoEJgDxAAABBwJsA24AAAALtgMRAgEAmlYAKzQAAAQAkQAABTgFsAADAAcADQARAC9AFw8ODgsMBAQMDAsHBwsLABADCHIIAAJyACsyKzISOS8zLxEzETMvERI5ETMwMVMzESMBMxEjASEBISchBzcBIZH7+wFXnp4B8wEz/h7+GCIBmwi3Acz+wgWw+lAES/04BC38wNmzqvzAAAQAjQAABKwEOgADAAcADQARAC1AFg8ODgsEBAwMCwcHCwsAEAMKcgkABnIAKzIrMhI5LzMvETMRMy8RMxEzMDFTMxEjATMRIwEhASEnIQc3ASGN8fEBTJSUAYwBLP5z/kIfAXQQtgFr/ssEOvvGA1P9pQNC/XXasYn9nwAEADQAAAaiBbAAAwAHAA0AEQAjQBEQDw8LCgoDDgYIcg0HAgMCcgArMjIyKzISOS8zMxEzMDFBFSE1IREjESEBISczARMBNwECYP3UAtX6BGf9r/6dIvoBqDP+KKICYwWwwMD6UAWw/MLaAmT6UAKYwfynAAQAPAAABaQEOgADAAcADQARACNAERAPDwsKCgMOBgpyDQcCAwZyACsyMjIrMhI5LzMzETMwMUEVITUhESMRIQEhJzMBEwE3AQJQ/ewCg/EDs/4Z/u0gyQEkE/67vQHFBDrAwPvGBDr9ddoBsfvGAdiJ/Z///wCU/poF1gWwBCYALAAAAQcCbASDAAAAC7YDDwoAAJpWACs0AP//AIT+mgTNBDoEJgD0AAABBwJsA3oAAAALtgMPCgAAmlYAKzQAAAQAlAAAB48FsAADAAcACwAPAB9ADwcGBgoCAwMMCwJyDQoIcgArMisyMhEzETkvMzAxQRUhJxEVITUTESMRIREjEQeP/YC6/Pw++wSD+wWwwMD9oMfHAmD6UAWw+lAFsAAABAB9AAAFawQ6AAMABwALAA8AH0APBwYGCgIDAwwLBnINCgpyACsyKzIyETMROS8zMDFBFSE3AxUhNRMRIxEhESMRBWv+QwJX/c9G8QOK8gQ6wMD+PL6+AcT7xgQ6+8YEOgACAJf+xAf1BbAABwAfABlADAgJCRQEBwJyBghyAgAvKysyLzkvMzAxQREjESERIxEBNTMyHgIVFA4CIycyPgI1NC4CIwUT+/16+wQI/ordnlM6e8OIAVNqOxgvWoZYBbD6UATo+xgFsPzMxkuU2Y53zpxXtz9sh0dikmMxAAAEAH3+5wa2BDoAFAAYABwAIAAjQBEeFxgYAAEBCx0cBnIbCnIMCwAvMysrMhE5LzMyETMvMDFBNSEyFhYVFA4CByc+AjU2JiYjARUhNTMRIxEhESMRA2UBIKT9kClakWVZT2IvAVGPYP7H/ek58QOM8gHNxm7WnTmKhGkbqBtUcERdfkACbcDA+8YEOvvGBDoAAAEAZ//rBeAFxQBDAB1ADjkMDCMiA3IAAQEuFwlyACsyMhEzKzIyETMwMWUVIiQmAjU1ND4CMzIeAhUVFAIGBCMiLgI1NTQ+AjMVIg4CFRUUHgIzMj4CNTU0LgIjIg4CFRUUHgIF4MT+wOd8PG6bXmOhdT9nwP72opb2r19Hg7duNlc8IDdplV9vr3pAGTFGLSpCLhlToeuvxGvFAQ6j03XHlVNUmtN+zpj+/MJtabz6kcGD4adezz5ulVfDZ7CCSU6KuWziWIJYKy1XflLXdsWRTwAAAQBg/+sEzARPAEMAHUAOOQwMIyIHcgABAS4XC3IAKzIyLzMrMjIRMzAxZRUiJCYmNTU0PgIzMh4CFRUUDgIjIi4CNTU0PgIzFQ4DFRUUHgIzMj4CNTU0LgIjIg4CFRUUHgIEzKr++rJcL1Z7S01+WS9Rls9/eMSOTTlpkFkhNSYVJ0pqQkt4VCwPHiobHCsdD0OBu42gVpzQeYFbmnI/RXymYH9zxZRSV5vPeU5mrYBIxgIpSWQ7UE+HZTc1XoBLgTRZRCYiPVQxhVeUbDwA//8AJv6aBSIFsAQmADwAAAEHAmwDzwAAAAu2AQ8GAACaVgArNAD//wAf/poEJQQ6BCYAXAAAAQcCbALSAAAAC7YBDwYAAJpWACs0AAADACn+oQa4BbAAAwAJABEAHUAOCQ0NCAoIcgUQDAIDAnIAKzIyMi8rMjIRMzAxQRUhNQEDIxEjNQURMxEhETMRA+f8QgaPE+eC/E38Aob7BbDAwPsZ/dgBX8nJBbD7FwTp+lAAAwAn/r8FOgQ7AAMACwARAB9ADwIDAw0KBQZyCAcHEAQKcgArMjIRMysyLzkvMzAxQRUhNRMRMxEhETMRNwMjESM1Aur9PfXxAanxkxLeggQ7wMD7xQQ6/IYDevvGv/4AAUG///8Akf6aBakFsAQmAOEAAAEHAmwEVgAAAAu2Ah0ZAACaVgArNAD//wBg/poEogQ7BCYA+QAAAQcCbANPAAAAC7YCGwIAAJpWACs0AAADAIEAAATeBbAAAwAZAB0AI0ARAwMKChUCAhUVBBwIchsEAnIAKzIrETkvMy8RMxEzLzAxQREjEQEzERQWFjMyPgI3FQ4DIyImJjUBMxEjAw2d/hH7P35fLmZnYCgnXGVoM6XwggNi+/sEEP0kAtwBoP49Z3UwCA8VDccMFg8IX86mAcP6UAAAAwB1AAAD9wQ7AAMABwAbACNAEAAAGBgNAQENDQUKchIEBnIAKzIrMi8zfS8RMxEzGC8wMUERIxEBESMRExUOAiMiJiY1ETMRFBYWMzI2NgKNnQIH8YorbXg9j89w8TBiSz1wagMs/aACYAEO+8YEOv4hvxMfE1i3jQFI/rhRYCoRHgAAAgCJAAAE5gWwABUAGQAZQAwBFwYRERcYAnIXCHIAKysROS8zETMwMWEjETQmJiMiDgIHNT4DMzIWFhUBIxEzBOb7P35gLWZnYScmXWVoMqbvg/ye+/sBw2h0MAgPFQ3HDBYPCF/Opv49BbAAAgAK/+kFtAXEAAkANgAlQBIFHQEBHR0GHBwKJBUDci8KCXIAKzIrMhE5LzMzETMvETMwMVMzFBYWMxUiJiYBIi4CNTU0PgIXMh4CFRUhNSE1NC4CIyIOAhUVFB4CMzI2NxcOAgqyMWROg7VdA8We8aNSWJzQeYnQjUb8QwLDIUh1VE55UiorXZdrfrI3MBdqpQQ5R2k6r2S5/CxcqOaJ/4jipVoBXrH6mom+IE+KaDo/cJJU/1aYckExGcIOKiIAAv/L/+wEkAROAAgANQAlQBIEHAEBHBwFGxsJIxQHci4JC3IAKzIrMhI5LzMzETMvETMwMUMzFBYzFSImJgEiLgI1NTQ+AjMyHgIVFSE1ITUuAyMiDgIVFRQeAjMyNjcXDgI1pmhteqlYAxN4wIhHSYWzaXWtdDn8uwJXAhs1VDw8XT8gJ0xsRViHMoAjcaEDXGR2oVyq/QVPjsBvKH/Ok05OjcJ1Z60TMFpHKDNgh1QoR3laM0ZAezNdOgADAJH+vATvBbAAAwAJACEAIUAQCgYGCwgHBxcWCQMCcgIIcgArKzIvMzkvMzMzETMwMUERIxEhASEnMwEBNSEyHgIVFA4CIycyPgI1NC4CIwGM+wRL/ZL+1iLeAar95wEGiN6eVDp8xosBU2o6Fi1Zg1QFsPpQBbD8w98CXvzCzUqU2pBzzp9bvkFshENhkWIwAAMAjf7nBEEEOgADAAkAHgAhQBAWFQkGcgYKCgcLCwEDBnIBAC8rEjkvMzMRMysvMzAxQREjESEBIyczAQE1ITIWFhUUDgIHJz4CNTQmJiMBfvEDtP4D/h+zATr90gEjo/2QKlmQZllPYjBQj2AEOvvGBDr9ddoBsf12xWXNnTmFgGcaqBpRakJddTj//wAs/oAF1gWwBCYA3QAAAQcAEAR4/8gAC7YDJAYAAJhWACs0AP//ACD+gATbBDoEJgDyAAABBwAQA33/yAALtgMkBgEAmFYAKzQAAAEAmf5LBRMFsAAZABlADBkIchcCAhEKBQACcgArMi8zOS8zKzAxUzMRIREzERQGBiMiJic3FhYzMjY2NREhESOZ+gKF+1ehcCQ9JA4UOBcpOh79e/oFsP2CAn76GHuqWAcKwwYGKlE6AqP9lQAAAQB9/ksEBwQ6ABkAHUAPGQpyFwICABEKD3IFAAZyACsyKzISOS8zKzAxUzMRIREzERQGBiMiJic3FhYzMjY2NREhESN98QGn8lWfbyI9Ig4TOxQqOh7+WfEEOv48AcT7iHmoVgcKuwYGK1I6Afb+SAD//wCU/oAF4QWwBCYALAAAAQcAEASD/8gAC7YDFgoBAJhWACs0AP//AIT+gATZBDoEJgD0AAABBwAQA3v/yAALtgMWCgEAmFYAKzQA//8AlP6ABywFsAQmADEAAAEHABAFzv/IAAu2AxsPAACYVgArNAD//wCP/oAGOwQ6BCYA8wAAAQcAEATd/8gAC7YDGQsBAJhWACs0AAABAFX/6wUjBcQALAAbQA0aCxEUFAslAANyCwlyACsrMhE5LzMRMzAxQTIEFhYVFRQOAiciLgI1NSEVIRUUHgIzMj4CNTU0LgIjIgYHJz4CAneoAQCsWF+n34GX55tPBCD82idWjGVYiF0vMGald4S8OzAYcK4FxGW3/Zd7l/23YwFdsfmaj8MhT4pnO0qDrWJ7Y62DSzIYwg0sIQACAFv/6wRLBbAABwAlAB9ADwUICAQlJQAcEglyBwACcgArMisyETkRMzMRMzAxUyEXASM1ASEBNzIWFhUUDgIjIi4CNTMUFhYzMjY2NTQmJiMjkQOXAf4cpwFp/YoBDaWl6HtMi7xwW6+PVPs8bEpUdj9EhmCJBbCh/dd3AYv+cglrzZRmoG05MWehcD5nPTxoQWV+OwACAF3+dQRHBDoABwAlAB9ADggFBQQlJQAcGBIHAAZyACsyL8wzEjkvMzMRMzAxUyEXASM1ASEBNzIWFhUUDgIjIi4CNTMUFhYzMjY2NTQmJiMjjgOTAv4jqQFi/Y8BD6Gl6XtMibxvWq+NVPI9cEtWeEBFiGKJBDqa/c53AZX+Zghqy5Nmn205MWehb0BpPz1rQ2Z/Ov//ACz+SwSFBbAEJgCxTgAAJgJBnygABwJvATAAAP//ACP+RwOaBDoEJgDsTgAAJwJB/5b/dgAHAm8BAv/8//8AJv5LBVMFsAQmADwAAAAHAm8DyAAA//8AH/5LBFYEOgQmAFwAAAAHAm8CywAAAAEATwAABHkFsAAYABK3AwAACxANAnIAKy8zOS8zMDFBIRUhIgYGFRQWFjMhETMRISImJjU0PgICXgFt/pNgejo6emABIPv95absfUeIwwOZx0l1Q0V5TATp+lB40YZkp3xDAAACAGgAAAatBbAAGAAtAB9ADhsLCxAlJQMAABoQDQJyACsvMzkvMzMvETMRMzAxQSEVISIGBhUUFhYzIREzESEiJiY1ND4CASM1Nz4CNzYuAiczHgIHDgICdwFt/pNgeTo6eWABIfr95absfUeIwwLnjIxJWioCAQgPFw/0Eh8UAgJwzAOZx0l1Q0V5TATp+lB40YZkp3xD/GfGAQFMekUnX2ZfJzOEhTaP0nIAAwBf/+kGewYYABYAKwBHAB1AEDNEC3I7LQFyHRILcicGB3IAKzIrMisvKzIwMVM1ND4CMzIeAxcVDgMjIi4CNxUUHgIzMjY2NzUuAyMiDgIFETMRBhYWMz4DNzYmJzMWFgcOAyMGJiZfN2ueZ0t4XEMqCgw8Y45fZZ1sN/IaOVtBUm0/CwcmP10+QVw5GwG+8gEjQSw8Wj8hAgIhHusbKgICT4iuYnOoXwH7FX7SmlQyXoSjYEN0v4tLTo7BiBVHeVsyR3lMtTtoTS07aYr2BLD7UDdVMAEyXYNSZMtkYctni8+IRAJNqgAAAgA9/+kF5AWwACAARgAhQBAoJycCAQEOMkMJcjoNDgJyACsyLysyETkvMzMRMzAxQSM1MzI2NjU0LgIjITUhMh4CFRQOAwciBgYHBgYTNTU0JiYjNzIeAhUVFBYWMz4DNzYmJzMWFgcOAyMGJiYBv92oaH46HkFoSf6jAV1/w4REID5ceEsCBwcDKBjMNmVGEoSwaS0aMiI0UzgfAQIiHvUaKwICT4asYGmaVgJnyTNmTDBNOB3JNWmZZjhhU0ExEBYVAQkE/s0CQEdpPHc0X4FNRCc8IwExXYBPZMtkYctnis+JRAJDlQAAAgAv/+QFAQQ6AB0AQgAlQBI+PT0bAgEBDSoqIjMLcgwNBnIAKzIrMjIvETkvMzMzETMwMUEhJzMyNjY1NCYmIyEnITIWFhUUDgIHDgIHBgYFNQYWMz4DNzYmJzMWFgcOAyMGLgInNTQmJiM3MhYWFQGL/vsCukVUKChXRf76BgEMjMRmI0VlQQIFBQMiDwFdASMwLEUwGgECIR/rGiwCAkV1llNQeFItBCRGMyWLnUEBobgiPiorRSi/TJFlMlJAMBEBHyACCAO6ASg2ASdHZUBNpU1NolBwqG83ARo6XUFMKDkehEFxSQAAAwBK/rYEPgWwAB8ANAA/AB9ADjo5PywMDQJyISAgAQECAC8zETMRMysyLzMvMzAxQSE1MzI2NjU0JiYjISchMhYWFRQOAwcOAgcOAgc3MhYWFRUUFhYXFSMuAjU1NCYmARUUBgcnPgI1NQGp/u7OZXs6OHhe/twDASei5XgdOVZwRQIIBgMaFRAxLKrCUA0eHPgeHAY6bgJjZlSBHC4cAl3ANmdJSGo7wGK8iDlgUkIxEQETEgEGCQUDgWCobHgiVEwZFxthYBh0TG47/oqtZtdHTC1baD+2AAADAHP+qAQcBDoAHgAzAD4AHkAOOCAfHwIBAT4rCgwNBnIAKzI/MzkvMzMRMy8wMUEhNTMyNjY1NCYmIyEnITIeAhUUDgIHBgYHDgIHNzIWFhUVFBYWFxUjLgI1NTQmJgUVFAYHJz4CNTUB3P7V60dbLCxbR/7bBAEpaaZ1PSZMb0kECAQXDgxFOpOlRQgUEvkTEAMtWAIuZlSBHC4cAZ2vJEIsLUgpvi5Xe042V0Y0EQEgAgQIBwF7SoFTVhE7OBAQEERDDlQ0SibErWbXR0wtW2g/tgAAAwBC/+sHfQWwABEAFQAyAB1ADiYmHi8JchcUABUCcgsIAC8zKzIyMisyMi8wMUEzAw4EIyM1Nz4ENwEVITUBETMRFB4CMzI+Ajc2JiczFhYHDgMjIiYmAXn6IwcoRGmQYUEoNE03IxUFAuj9hQI++xMlMyE5Vz0hAQIhHvUaKwICUIivYXavYgWw/S2f8qxtM8cDBCtViMSDApPJyfu7BEX7uylEMRoyW4FQZMtkYctni8+IRE2qAAMAP//rBlgEOgARABUAMwAfQBAnJx4vC3IXFAAVBnILCApyACsyKzIyMisyMi8wMUEzAw4EIyMnNz4ENwEVITUBETMRFB4CMzI+Ajc2Jic3FhYHDgMjIi4CASfuHQYiO1RwRksBJiU2JhoPBAJG/hUBqfEVKDcjL0gyGwECIR3qGiwCAkh5nVdYkGg4BDr96Xe1gVAmxgMDIT5ihlkBzsLC/S4C0v0uKUYyGyxSc0hfwF4BXcBhf79+PitckAADAJT/6Qd8BbAAAwAHACMAIEARFhYOHwlyCAJyAAMDBggEAnIAKz85LzMrKzIyLzAxQSEVIQMzESMBMxEUFhYzPgM3NiYnMxYWBw4DIwYmJicBUQL2/Qq9+/sDdvshPiw5Vz0hAgIiHvQbKwICUIivYXWqYAcDMscDRfpQBbD7uzZTLwExW4FQZMtkYctni8+IRAJOq4kAAAMAdP/qBlcEOgADAAcAJQAiQBIZGRAhC3IJBnIDAgIFBwZyBQoAPysSOS8zKysyMi8wMUEVITUTESMRAREzERQeAjM+Azc2Jic3FhYHDgMjBi4CA0H940LyAqHyFCg4Iy9IMhsBAiEd6hosAgJHep1XWYxlOQJ8v78BvvvGBDr9LgLS/S4pRjIbASxRc0hfwF4BXcBhf79+PgEqXJIAAQBc/+sEvwXFACsAFUAKEgsDciUlHQAJcgArMjIvKzIwMUUiLgI1ETQ+AjMyFhcHJiYjIg4CFREUHgIzPgI3NiYnMxYWBw4CAruH36JXV6Lfh3SuQzxBkVdThF0wMF2EU1R0PQICHRf0FCcCApDoFV2n4YUBBoXhp10sLLUhI0Fyl1X++FaYc0EBPnJOV7NWVrFZmspjAAABAFX/6wPrBE4AKwAVQAohGgdyBwcADwtyACsyMi8rMjAxZT4CNTQmJzMWFgcOAiMiLgI1NTQ+AjMyFhcHJiYjIg4CFRUUHgICWzxDHgkK6gsRAQJps3F8woREQn+5eGCNLC0ueEZFYT4cH0JqrAEkPyw1czU2cDdylklXl8NsKmzDllciH7ocHj1lez4qPnxlPQAAAgAh/+kFVwWwAAMAIAAXQAsUFAwdCXIFAgMCcgArMjIrMjIvMDFBFSE1AREzERQeAjM+Azc2JiczFhYHDgMjBiYmBKH7gAHE+hMkNCA6Vz0gAgIiHfQbKwMCT4ivYnWqYAWwycn7uwRF+7spQzEbATFbgVBky2Rhy2eLz4hEAk6rAAIARP/qBMsEOgADACAAF0ALExMLHAtyBQIDBnIAKzIyKzIyLzAxQRUhNQERMxEUFhYzPgM3NiYnMxYWBw4DIwYuAgPP/HUBRfAlRS8vSDMbAQIhHuoaLAICSHmdV1iNZToEOr+//S4C0v0uN1UwASNCXTtLnktLm05wqW83ASpckgACAH3/6wT7BcUAIAA/ACNAEQAiPz8CAhc1MSwDchENFwlyACsyzCvMMxI5LzMSOTkwMUEzFSMiDgIVFB4CMzI2NjUzFA4CIyIuAjU0PgIFIyIuAjU0PgIzMhYWFSM0JiYjIgYGFRQeAjMzAqDcwE95UiotV35RXIxO+mGhx2eB159XSYzMAV7cdsGLS1CW0YGS9pT7TYNRbYxDIklyUMADEYwcOVs+MVM/Ij1nPnChZzE5baBmW41gMlc5ZIRLZptpNWO3gEBeNDtiOzJQOx///wAs/ksF/QWwBCYA3QAAAAcCbwRyAAD//wAg/ksFAgQ6BCYA8gAAAAcCbwN3AAAAAwB0/+sE9wXEAAMAGAAyAChAFBAnJw8ABAolJQodMAlyFAoDcgIIAD8rMisyETkvEjk5MzMRMzAxQREjERcjND4CMzIEFwEjNQEmJiMiDgITNxYWMzI2NjU0JiYjIzU3MhYWFRQGBiMiJgFl8fHxO3e2ea4BEXv+UZcBHzKDXkJbORpvRSVxR1Z5QUWHZI2kpul7guGMWpgDwPxAA8ACgMOCQYVn/f95AVQnOi5WefwZuxEgPGxIYXc3oghlxI2NwmQdAAIAZARwAsYF1wAFAA8AErYFBQ0HAgIHAC8zLxDNMi8wMUE1EzMVAyU1MxUUFhcHJiYBi3LJ4v6AqCYqTU9cBIQUAT8V/sL5WlRCYidIKI3//wBQAg4CYQLOBAYAEQAA//8AUAIOAmECzgQGABEAAAABAJwCcASaAzEAAwAIsQMCAC8zMDFBFSE1BJr8AgMxwcEAAQB7AnAFzAMxAAMACLEDAgAvMzAxQRUhNQXM+q8DMcHBAAIACP5mA5cAAAADAAcADrQCA4AGBwAvMxrOMjAxQRUhNQEVITUDl/xxA4/8cf7+mJgBApiYAAEAZQQmAY8GGwAKAAixBQAAL80wMVM1NDY2NxcGBhUVZS1RNHgoMwQmiD+HeyxLP4tXiQABADcEBQFhBgAACgAIsQUAAC/NMDFBFRQGBgcnNjY1NQFhLVA0eSkzBgCNP4d7LUw+i1ePAAABADX+2wFhAM8ACgAIsQUAAC/NMDFlBxQGBgcnNjY1NQFhAS1QNHoqLs+GP4d7LUs/i1eIAAABAEsEBQF2BgAACgAIsQYAAC/NMDFTMxUUFhcHLgI1S88zKXkzUS4GAI9Xiz5MLXuHPwD//wBtBCYC3wYbBCYBhQgAAAcBhQFQAAD//wBEBAUCtQYABCYBhg0AAAcBhgFUAAAAAgA1/sgCoQD+AAoAFQAMsxAFCwAALzLNMjAxZQcUBgYHJzY2NTUhBxQGBgcnNjY1NQFhAStONH4qLgIUAS1QNH4qMv61Qo+CLktElFy3tUKPgi5LRJRctwAAAgA/AAAEHQWwAAMABwAVQAoGBwcCAwJyAhJyACsrETkvMzAxQREjEQEVITUCpPECavwiBbD6UAWw/orExAADAF3+YAQ6BbAAAwAHAAsAHUAOCwoGBwcBAwoScgMCcgEALysrERI5LzMRMzAxQREjEQEVITUBFSE1AsHyAmv8IwPd/CMFsPiwB1D+isDA/IbAwAABAIoCBgJGA9cADQAIsQQLAC/NMDFTNTQ2MzIWFRUUBiMiJop3Zmd4d2dmeALaJ154eF4nXXd3//8Ajf/0A28A/QQmABIHAAAHABIBzwAA//8Ajf/0BSgA/QQmABIHAAAnABIBzwAAAAcAEgOIAAAAAQBeAfABcgLvAAsACLEDCQAvzTAxUzQ2MzIWFRQGIyImXklAQUpKQUBJAm83SUk3N0hIAAcAUP/rB2MFxQARACMANQBHAFkAawBvAClAE19WVjJoTU1EKSk7Mg0XDg4gBQUAPzMzLzM/MzMvMzMvMxEzLzMwMVM1NDY2MzIWFhUVFAYGIyImJjcVFBYWMzI2NjU1NCYmIyIGBgE1NDY2MzIWFhUVFAYGIyImJjcVFBYWMzI2NjU1NCYmIyIGBgU1NDY2MzIWFhUVFAYGIyImJjcVFBYWMzI2NjU1NCYmIyIGBgEBJwFQSIdcYopJSYlhXYdJnx9ALzA+Hh8/MC8+HwJDS4pfW39DQ39ZYItLqCFALTM9Gx8+MC8/HgE5RH9ZYYpJSYlgWoBEkCE/LjM9Gx8+MC8/Hv7p/Tl8AscES01TiFJSiFNNUYhSUoieTShILCxIKE0pSC0tSPxWTlKIUlKIUk5SiFJSiKBOKEgtLUcpTilILCxId05SiFJSiFJOUohSUoigTihILS1HKU4pSCwsSANS+45HBHIAAAIAbACLAjADqQAEAAkAEkAJAQUDCQIIBgYAAC8vFzkwMUEDJzUBAxMjATUCMPvJAR9W+6X+4QOp/m0BDQGF/nb+bAGGDQACAFUAiwIaA6gABAAJAA60AggIBQAALy85LzMwMXcTFxUBAzMBFQdV+8r+4aamAR/KiwGTAQ3+ewMd/nsNAQAAAQArAG4DbgUnAAMADrMAAwIBAHwvMxgvMzAxQQEnAQNu/Tl8AscE4PuORwRy//8ATAKQAqkFuwYHAeIAAAKb//8ANgKbAr8FsAYHAjsAAAKb//8AUAKQAq0FsAYHAjwAAAKb//8ATgKQArgFvQYHAj0AAAKb//8ANwKbAq0FsAYHAj4AAAKb//8ASwKQAqoFuwYHAj8AAAKb//8ARwKRAqMFuwYHAkAAAAKbAAIAUAKPAukFUQADAAcAFbcGBgICAwcHAwAvMy8RMxEzfS8wMUEVITUBESMRAun9ZwGdoAQ7l5cBFv0+AsIAAQBQA6YCowQ+AAMACLEDAgAvMzAxQRUhNQKj/a0EPpiYAAIAUAMdAqMEwAADAAcADLMCAwcGAC8zzjIwMUEVITUBFSE1AqP9rQJT/a0DtZiYAQuXlwABAFMBhAGzBjMAFQAMsxARBgUALzMvMzAxUzU0NjY3Fw4CFRUUHgIXBy4DU1qEPUUnSi8bLzkdRS5jVTUD0xGj85seeyd3s4ITZpduTxx4F2KVxwABAFABhAGwBjMAFQAMsxARBgUALzMvMzAxQRUUBgYHJz4CNTU0LgInNx4DAbBbgz1FJ0kwGy46HUUtY1Y1A+QRo/SZH3gmdLWHE2GVb1EdexZklcYAAAIAZwKMAwAFugAEABkAE7cWCwQECwIRAgAvMz8zLxEzMDFBESMRMxMHND4CMzIWFhURIxE0JiYjIgYGASa/lRMvJkloQlF2QMAhPSs8SiIFAf2LAyH+iQFUjmk6P4hs/gUBy0hUJT1lAP//AEz+iAKpAbMGBwHiAAD+k///AIL+lAIBAagGBwHhAAD+lP//AD3+lAKwAbQGBwHgAAD+lP//ADf+iQKpAbQGBwI6AAD+lP//ADb+lAK/AakGBwI7AAD+lP//AFD+iQKtAakGBwI8AAD+lP//AE7+iQK4AbYGBwI9AAD+lP//ADf+lAKtAakGBwI+AAD+lP//AEv+iQKqAbQGBwI/AAD+lP//AEf+igKjAbQGBwJAAAD+lP//AFD+qALpAWoGBwGdAAD8Gf//AFD/vwKjAFcGBwGeAAD8Gf//AFD/NgKjANkGBwGfAAD8GQABAFP96gGzAlcAFAAIsQUQAC8vMDF3NTQ2NjcXDgIVFRQWFhcHLgNTWoQ9RSdKLzBKJkUuY1U1FhGb5pIdeyRvqHkTfqZrJXcVXI26AAABAFD96wGwAlcAFAAIsRAFAC8vMDFlFRQGBgcnPgI1NTQmJic3HgMBsFuDPUUnSTAvSShFLmNVNTEQnemUHHgkbauBEnekbCN7FVuLuQAEAGIAAAR6BcQAAwAeACIAJgAiQBAiISUmJgEbFxIFcgkCAgEMAD8zETMrzDMSOS8zzjIwMWEhNSEBExYGByc+AjUDNDY2MzIWFhUjNCYmIyIGBgUVITUBFSE1BHr76QQW/XcXAUdRtiEjDRVzyoOLwmbyOFs1NlcyAUL9MALQ/TDHA0j9lGCXK0YIRV0pAnWKw2hmtXhLWSg2avGNjf73jo4AAAMAIwAABksFsAADAAcAEQAiQBADAgYLDhAHBw0RDgRyCg0MAD8zKzISOS85EjkzzjIwMUEVITUBFSE1AREjAREjETMBEQZL+dgGKPnYBVL6/XP7+wKPA8Sbm/7Jm5sDI/pQBBP77QWw++sEFQAAAwCZ/+wGQQWwABcAGwAtACNAEiIpDRwZGAZyAgEBDgwPBHIODAA/KzISOS8zKzLMPzMwMUEjNTMyNjY1NCYmIyMRIxEhMhYWFRQGBgEVITUTMxEUFhYzMjY3FwYGIyImJjUCI9vbY20qKm1jkPoBiqvdbGzdA2r9n6/xHTQiGS8OAR5PM1OASAIdyUp3QkF0SfsZBbB2zYKF0XgCHbCwAQn76DI1EgYDuAkOO4ZvAP//AJT/7Ag9BbAEJgA2AAAABwBXBHYAAAAGACMAAAYYBbAAAwAHAA0AEgAXAB0AKkAUHRUKChIGBwMCAhESBHITGxsIEQwAPzMzETMrEjkvM84yETMRMzMwMUEVITUBFSE1ARMTMwMDARMTIwEBExMzAQETEyMDAwYY+gsF9foLAcEYspMJvP7atRef/tkDuxix+v7Z/tm0FZu7BAQtmpr+wpqa/REBWwRV/qv7pQWw+6r+pgWw+lABXQRT+lAFsPuq/qYEXwFRAAIAfQAABh8EOgARACIAIEAPFhMTERQIFAgRChwPAAZyACsyMj85OS8vETMRMzAxUyEyHgIVESMRNC4CIyERIyEhETMRITI2NjURMxEUDgJ9Apddilos8hs0Si/+p/EDyv3U8QFaPlkx8UyEqgQ6LmKabf7CAT8/VDAT/IYC1/3pJF1VAqT9XWybYi4AAwBc/+wEMwXEACMAJwArAB1ADiorJyYmBxkSBXIABw1yACsyKzISOS8zzjIwMWUyNjcXBgYjIi4CNRE0PgIzMhYXByYmIyIOAhURFB4CExUhNQEVITUDTDZmLh06fkF7zZZTU5nRfz51Ox0sZzRNe1YtL1Z5aPzyAw788rIQEMgOEEiP1Y4BU5LblEoRDskPEi5dkmX+q2SNWSoC9YmJ/vSJiQADACMAAAXIBbAAAwAHAB8AKUATBgcDAgIUChQXCQoKFhcEchYMcgArKxI5fS8zETMREjkYLzPOMjAxQRUhNQUVITUBITUhMjY2NTQmJiMhESMRITIWFhUUBgYFyPpbBaX6WwLf/oUBe2J7OTl7Yv7S+wIpqO59fe4Eppub6pub/mPHQHFJRXlK+xgFsHfRho3KbAAAAwAqAAAEBAWwAAMAHAAgAC1AFR8gIBEDAgUGBhoCGgIaBBARBHIEDAA/KzISOTl9Ly8RMxEzETMRMxEzMDFBByE3AQEnMzI2NjU0JiYjITczMhYWFRQGBgcBFRMHITcEAzH8WDEB4/4JAe9deTw4emT++jbQsep1VsCfAcysMv0DMQRHsbH7uQJRlUNzR012Qshqyo99v3UO/d8NBbCxsQAABAAk/+0ESQWwAAMAFAAYABwAFUAJBAQDDwELDQMEAD8/MzMSOS8wMUERIxEBMxUUAgYGIyImJzcyPgI1AxUBNQUVATUB8PoCWPtXod6IRXo29VeEWi6D/VkCp/1ZBbD6UAWw/U9PpP76uGELCLlBfr17AnvC/vXCQML+9cEAAgBPAAAFEgQ6ABsAHwAYQAsIFRUeHwZyDgEeCgA/MzMrEjkvMzAxYSM1NC4DIyIOAhUVIzU0EjY2MzIeAxUBESMRBRLxIEBackVTh2E08luj3oVsu5ZsOf4X8rNjoXpTKkKAvXyzsaUBBrhhP3is3YQDifvGBDoAAgArAAAFMgWwABcAGwAaQAwZGAMAAA4MDwRyDgwAPysyEjkvM84yMDFBITUhMjY2NTQmJiMhESMRITIWFhUUBgYHFSE1AyD9CwLwZXw6Onpi/tL7Aimo7H5/7Y788wIfxz9yTER2S/sYBbB2z4aPy2xrx8cAAAQAbv/rBYoFxQAhADMARQBJACVAEkInMEdHOTANch8FDklJFg4FcgArMjIvEMwyKzIyLxDMMjAxQTMUBgYjIiYmNTU0NjYzMhYWFSM0JiMiBgYVFRQWFjMyNgE1NDY2MzIWFhUVFAYGIyImJjcVFBYWMzI2NjU1NCYmIyIGBhMBJwECB6hCgFxcgkVEgltdgEOoOz0pNhobNyk9OQEbSYphZIlHR4hjYotJqCFALTM+Gx8/MC8+H8D9OXwCxwQjRXZIUohRTVOIUkh3Ri1JLEkpTShILEz9HE5SiFJSiFJOUohSUoigTihILS1HKU4pSCwsSANS+45HBHIAAAEARf/rA48F9gAuABS3GRgYASQMAAEALzMvMxI5LzMwMWUVIi4CNRE0PgIzMh4CFRUUDgIEIzUyPgI1NTQuAiMiDgIVERQeAgLbdq9zOS5YfU5DcFMuSIzM/vehouqVRwsWHBEWIhcMFTJTwtdAd6dmAqZim2w4LVd6TSleyr2ZWbRnpr5WKyAyIREYMUgy/WE/YkYkAAQAkAAAB7wFwAADABUAJwAxACVAESswLioCAxsSJAkJMS4EKi0MAD8zPzMzLzPcMs4yERI5OTAxQRUhNQM1NDY2MzIWFhUVFAYGIyImJjcVFBYWMzI2NjU1NCYmIyIGBgERIQERIxEhAREHkv2jKVWaaWuZVFOZamqbVagmUDw7TiYnTjw7Tyb+zP73/gvyAQkB9gIvj48B3lNnn1pan2dTZ55aWp66Uz1eNjZePVM8Xjc3XgEU+lAEE/vtBbD76wQVAAACAG8DlQRdBbAADAAUACRAEQkEAQMGCgcHExQCAAMDBgYRAC8zETMRMz8zMxEzEhc5MDFBEQMjAxEjETMTEzMRARUjESMRIzUD7ntAfG+JgoaE/aCJeI0DlQF1/osBdv6KAhv+gQF//eUCG17+RAG8XgACAJb/7ASRBE4AHQAmABdACiIXFwQeDgcbBAsAPzM/MxI5LzMwMWUXBgYjIi4CNTQ+AjMyHgIVFBQVIREWFjMyNgEiBgcRIREmJgQSAlS8Ym2+kFFZlrtiZ7OITf0AN4xOXbv+6EuNOQIcNIrGaDQ+WJrMc3TLmlhRksV1AxIa/rgzOzsDaUI4/usBHjQ9AP//AFv/9QXMBZoEJwHh/9kChgAnAZUA/wAAAQcCPwMiAAAAB7EGBAA/MDEA//8AVv/1BmoFtAQnAjoAHwKUACcBlQGoAAAABwI/A8AAAP//AF7/9QZbBagEJwI8AA4CkwAnAZUBjgAAAQcCPwOxAAAAB7ECBAA/MDEA//8AXP/1BhsFpAQnAj4AJQKPACcBlQE3AAABBwI/A3EAAAAHsQYEAD8wMQAAAgBh/+sERgX3ACkAPwAZQAwqAAASNR8LcgkSAHIAKzIrMhE5LzMwMUEyFhcuBCMiBgYHJz4CMzIeAhIVFRQOAyMiLgI1NTQ+AhciDgIVFRQeAjMyPgI1NS4DAjlWmTsKLUFTYjc1U08uICRXck1ssohcMCpUeZ1fd7mAQj56r41FYj4dHT1iREViPh4JJj1ZBAVCQE+HakomDBkSshEiFkiLyv7+nDtwyKR5QVCPwXIVa7eHSr8zWHE/FkN4WzQ/bpNUWhg8NSQAAAEApv8WBOgFsAAHAA61BAcCcgIGAC8zKzIwMUERIxEhESMRBOjy/aPzBbD5ZgXd+iMGmgADAD/+8wTDBbAAAwAHABAAH0AODgYGBwcPAnIMAwMKAgsALzMzMxEzKzIRMxEzMDFFFSE1ARUhNQEVASM1AQE1MwTD+9gD8/wKAvD9W6QCSv22pE6/vwX+v7/8sR38r5ECzwLLkgABAJwCcAPvAzEAAwAIsQMCAC8zMDFBFSE1A+/8rQMxwcEAAwA7//8EfAWwAAQACQANABZACgkLCwoECAgBAnIAKz8zLzMRMzAxZQEzASMDExcjAQc1IRUCKwF/0v4onWuzIJL+5IYBU+kEx/pPAwP94eQDA8LCwgAEAGH/6wfqBE4AFwAvAEcAXwAdQA5bNjYeEwtyTkNDKwYHcgArMjIRMysyMhEzMDFTNTQ+AjMyHgMXFQ4EIyIuAjcVFB4CMzI+Azc1LgQjIg4CBRUUDgIjIi4DJzU+BDMyHgIHNTQuAiMiDgMHFR4EMzI+AmFHg7hyaqV6VDYODjZUeqRpc7mDR+0jRmZCQWZNNB4EBB4zTWhCQWZFIwacR4S5cmqkelQ2Dg42VXqka3G5hEbtJEVlQUNnTTQeBAQeNE1mQkFmRiQCERdwx5lWT36SizIjMoyVgVBXmMeHF0qAYjY6W2JUFSMUUmBaOThigUgXcMeYV1CBlYwyIzKLkn5PVpnHhxdIgWI4OVpgUhQjFVRiWzo2YoAAAAH/p/5LAqgGFQAfABC3GxQBcgsED3IAKzIrMjAxRRQGBiMiJic3FhYzMjY2NRE0NjYzMhYXByYmIyIGBhUBjlWebyNAIhESLBYvQCFapnQmSycYEywfNUolTXmgTwgKugQII0s6BPF4pVQMCbUFBipPOQAAAgBlAQYEGAP5ABkAMwAbQAsXBIAKEUAxHoAkKwAvMxrdMhreMhrNMjAxUzU2NjM2FhcWFjMyNjcXBgYjIiYnJiYHIgYDJzY2MzYWFxYWMzI2NxUGBiMiJicmJgciBmYvhUFQYz87XkpBdy8BL3RBSl07P2RQQYkvAS+BQVBjPzteSkF8Ly93QUpeOz9kUEGEArfUMzkCKyAeJ0M80zM5Jx4gKwJE/iLUMjoCKyAeJ0M81DI6Jx4gLAJEAAADAI8AfwPzBL8AAwAHAAsAH0ANAgEBCgoLAAMDBwcGCwAvzjIRMxEzETMRMxEzMDFBAScBFxUhNQEVITUDkv3CbAI+zfycA2T8nASD+/w8BATtxsb+WMbGAAADAD0AAQOQBEsABAAJAA0AIkAQAwcGAAQIBgUJCQECAg0NDAAvM3wQzi8yMhgvMxc5MDFTBRUBNSUFBzUBExUhNfQClfy1A0v9a7YDSwf8rQLK3swBRIeU4R2GAUT8bri4AAMAfQAAA94EWAAEAAkADQAiQBADBwYABAgGAQICBQkJDQ0MAC8zfBDOLzIyGC8zFzkwMUElNQEVBSU3FQEFFSE1Ax/9XwNg/KACo738oANS/K0Cs93I/ryHmOEih/67c7m5AAACACUAAAPrBbAABwAPAB1ADgUICA4HEnIDCgoLAQJyACsyMhEzKzIyETMwMVMBMwcBARcjNwEBJzMBASMlAX+uKP7uARcdpj8BE/7rHqYBgP6CpgLXAtm1/dz927KxAiYCJLX9J/0p//8AnACqAbYFBgQnABIAFgC2AAcAEgAWBAkAAgBkAoQCMgQ6AAMABwAQtgYCAgcDBnIAKzIyETMwMVMRIxEhESMR+5cBzpcEOv5KAbb+SgG2AAABAEf/ZAFUAQAACQAKsgSACQAvGs0wMUEVFAYHJzY2NTUBVE1DfSQnAQBLV7w+Szh4TVT//wArAAAFGwYVBCYASgAAAAcASgJGAAAAAwAaAAAEHQYVABAAFAAYABtADxgGFwpyExQGcg0GAXIBCgA/KzIrMis/MDFhIxE0NjYzMhYXByYmIyIGFRcVITUhESMRAbLyacWIUJVQJTN8UW1n2f2PBAPxBICDtF4iGsQRH2NiRrCw+8YEOgADACsAAAQuBhUAEgAWABoAG0APGRoGchQAcg4GAXITAQpyACsyKzIrKzIwMWEjETQ2NjMyFhYXByYmIyIGBhUBETMRARUhNQHC8WG4gjSdqkdoXaBBQFguAXvx/nP9igSbe6hXDhULuRETK1E7+2UF5/oZBDqwsAAFACsAAAaaBhUAEQAVACYAKgAuACVAFCMcAXIuKhQVBnINBgFyLRcXAQpyACsyETMrMisyMjIrMjAxYSMRNDY2MzIWFwcmJiMiBgYVFxUhNQEjETQ2NjMyFhcHJiYjIgYVFxUhNSERIxEBwvFbqnQkRiEGFC8bN08p5f2EBAPxaMWIUJZPJTJ9UG1o2v2PBAPyBKJ5pVUJCboFBClOOWiwsPvGBICDtF4iGsQRH2NiRrCw+8YEOgAABQArAAAGmgYVABEAFQAoACwAMAApQBcrAHIkHAFyLhQULRUGcg0GAXIpFwEKcgArMjIrMisyMhEzKzIrMDFhIxE0NjYzMhYXByYmIyIGBhUXFSE1ASMRNDY2MzIWFhcHJiYjIgYGFQERMxEBFSE1AcLxW6p0JEYhBhQvGzdPKeb9gwQD8WG3gzSdqkdpXKBBQFktAXry/nP9igSieaVVCQm6BQQpTjlosLD7xgSbe6hXDhULuRETK1E7+2UF5/oZBDqwsAAABAAr/+wE0wYVAAMAFwAbAC0AJUAUIikLchMKcgkcHA0NBAFyGAIDBnIAKzIyKzIRMxEzKysyMDFBFSE1ATIWFxUjNSYmIyIGBhURIxE0NjYBFSE1EzMRFBYWMzI2NxUGBiMiJiY1AYz+nwIZdvBf8RlmMzVJJvFZpgL6/Z+v8R00IxkuDx5PMlR/SQQ6sLAB2z0q0FcNEypQOfteBKJ5pVX+JbCwAQn76DI1EgYDuAkOO4ZvAAAEAEn/7AaCBhQAGwAfADEAZwAxQBs7MkBkYFsLcgFFSUAHciYtC3IeEB8GchQKAXIAKzIrMjIrMisyzDIrzDMSOTkwMUEjLgI1ND4CMzIeAhUjNCYmIyIGFRQeAiUVITU3MxEUFhYzMjY3FQYGIyImJjUFNCYmJy4DNTQ+AjMyFhYVIzQmJiMiBgYVFB4CFx4CFRQOAiMiJiY1Mx4CMzI2NgPBeCZYPjRlkFx7pF8o8ixSOldQHCMbArj9pKnyHTQiGS8PHk8zU4BJ/hUkZWJWj2Y4OmybYIjDaPErVkE+UScVMldCfLNgPXShZJPMaekEQ2U2QVguAvdrqpdNPWpQLURxiUVDWy9cPzxmZnf2sLBZ/Ks3PRgGA7gJDkSUeRgkOzAUEzVMaERCdlo0W5thK0svJz4lGysjHg4aUX9hSHdXMGmlWUNPIyM9ABUAWf5yB+wFrgAFAAsAEQAXABsAHwAjACcAKwAvADMANwA7AD8AQwBHAFcAcwCMAJoAqAAAUyMRIRUjISM1IREjASERMxUzBSE1MzUzASE1IQUhNSERITUhARUjNRMVIzUBITUhARUjNQEhNSEFITUhARUjNRMVIzUBFSM1BxEzERQGIyImNTMUFjMyNiUjJzMyNjU0JiMjESMRMzIWFhUUBgYHIgYHBhQHIzczMjY1NCYjIzczMhQXFBYxHgIVFAYBFRQGIyImNTU0NjMyFgc1NCYjIgYVFRQWMzI2ynEBNcQGs8cBNm/6Ef7LccQGXv7Kx2/+Uf7qARb84P7sART+7AEUBM9vb2/9MP7rARX8HXEEVP7rARUBkP7qARb6jXFxcQeTb+hca1BYbV04MCk2/cKWAXY7Ozs7XV+8Ql8zIkEvAQQCDA65MIk0MzM0dwGXDgwHKzoeaf6Ef2ZngYBmZ4BcSkFASktBQEkEkQEddHT+4/nhATvKcXHK/sVxcXEGV3T7dPn5AvL6+vpecQI/+fkEGHR0dPzu/PwBePr6/oj8/PMBev6GT1xRUy4tN3JGKScpHv4vAiUgQjQiOCQEEwEEAfRLLCcnL0YBBQETBCY5IkxPAUhwYXp6YXBhenrRcERPT0RwRU5OAAUAXP3VB9cIcwADAB4AIgAmACoAAFMJAgMzNDY3NjY1NCYjIgYHMzY2MzIWFRQGBw4CEzUjFRM1MxUDNTMVXAO8A7/8QXfKGSlEYqeVf7ECywI+Jzg5NSgvPR3Jyn8EBgQCgwPP/DH8MQLeMz4bJYFSgJd9jTcwQDQ0TRohOk7+u6qq/UgEBAqaBAQAAQA9AAACsAMgABwAELUDHBwLEwIAL8wyMxEzMDFlFSE1AT4CNTQmIyIGFSM0NjYzMhYWFRQGBgcHArD9nwEfKTEXODVAP7ZJh15fhUcwW0ONkZF6AQklPzQSKzdHM0l6SDpsTDddXDd2AAEAggAAAgEDFAAGACNAFQQFBQMDLwB/AAIPAF8ArwD/AAQAAQAvzV1xMhEzETMwMUERIxEHNSUCAbXKAWwDFPzsAkAxj3YAAAIATP/1AqkDIAARACMADLMXDiAFAC8zxDIwMUEVFAYGIyImJjU1NDY2MzIWFgM1NCYmIyIGBhUVFBYWMzI2NgKpTIhZW4hNTIhaWohNth02JiY1HR03JiY1HAHWmHCSR0eScJhwkkhIkv7urT1MJCRMPa0+TCMjTAAAAQBP//QDuASdADIAF0AKFB4eJgExCgwmfgA/Mz8zEjkvMzAxZTMyPgI1NTQuAiMiBgYVFBYWMzI+AjcXDgIjIiYmNTQ2NjMyHgIVFRQOAiMjARkTbJtkMR42SCo9WC4sWEMwTTcfAUcCWJdjfKpYasSFZqFzPFCh9KUVtCtYhVrYPVk8HTxlPTpgOB4xOh1EQ4BTY7BzcrtxQXuwcEmb76VVAAAEAFf/8APGBJ0AEgAiADQARAAdQA0oFxdBDg4FOTF+HwULAD8zPzMSOS8zMxEzMDFBFA4CIyImJjU0PgIzMh4CBzQmJiMiBgYVFBYWMzI2NhMUDgIjIi4CNTQ2NjMyFhYHNCYmIyIGBhUUFhYzMjY2A8ZDdqBefcd0QXefX1+hd0LyMlo7O1kxMVo8O1kx1T1ulVpalm49abp2eLlr8SpMNTRLKSlNNDVLKQE/U31UK0uWbkx3VS0tVXc5M0gnJ0gzM0knJ0kCOERvUSsrUW9EapFLS5F2LEMkJEEuLUQmJkQAAQA4AAADzgSNAAYADrUFAQZ9AwoAPz8zMzAxQRUBIwEhNQPO/f/+AgH9aASNhfv4A83AAAEAX//wA9gEmwAxABVACRYfHw4nCwMAfgA/Mj8zOS8zMDFBMxUjIg4CFRUUHgIzMjY2NTQmJiMiBgYHJz4CMzIWFhUUBgYjIi4CNTU0PgIC9CIQa6NvOR84TS09WjEvWUBAZTsCQQNYnmx9pVNqwoZoqHdAV6n2BJvEL2CSYqs+Xj8fN186PFozMUwqR0CDW2ixbHK1akF5q2tQmfGpWAABAGb/8APQBI0AIwAXQAohCQkCGRELBQJ9AD8zPzMSOS8zMDFBJxMhFSEHNjYzMhYWFRQGBiMiJiYnMxYWMzI2NjU0JiYjIgYBRcBKAsb+AiMbb0R9sl9ewZVvxH0G7ghsVEZWJzJiRlBRAg4uAlHD+gwgW6t5abVvTpZsS0Y3Xzw8XTQpAAIAMwAAA+0EjQAHAAsAFUAJAAEBCgQLfQoSAD8/MxI5LzMwMUEVIScBMwMBAREjEQPt/FAKAiq90P7bAi3xAbvAlwL7/q3+gQLS+3MEjQAAAgA9//ADwASdAB0APQAdQA0fAAAdHh4SNCoLCRJ+AD8zPzMSOS8zMxEzMDFBMzI2NjU0JiYjIgYGFSM0NjYzMh4CFRQOAiMjFTUzMh4CFRQOAiMiLgI1MxQWFjMyNjY1NC4CIwFrfkdcLSdTQzZVMvJzwXZhoHU+NmqYYKiobaJqNER9pmFUnX9L8jReQENcLiA7VTUCpylILytEKCA8KmWRTypUfFE7Z1AtN3MoTG9GUn9YLShVglosRigpSTEtQSkTAAEAQwAAA9YEnQAeABK3CxR+Ax4eAhIAPzMRMz8zMDFlFSE1AT4CNTQmIyIGBhUjNDY2MzIWFhUUDgIHBwPW/IcBqUJNIlxWR10s8mrHi4a/ZCdKakP4v7+jAY49YU8gRlozWDhqsGhUnWs7amRoO9YAAAEAmAAAAsUEjQAGAAqzBn0CCgA/PzAxQREjEQU1JQLF8f7EAhIEjftzA3VTvq0AAAIAWP/wA8QEnQAVACsADrUcEX4nBgsAPzM/MzAxQRUUDgIjIi4CNTU0PgIzMh4CAzU0LgIjIg4CFRUUHgIzMj4CA8Q/c6FiYqF0QD90oGJionQ/8hoySTAuSTIaGjNKLi9JMhkCrc1/u3o8PHq7f81/uns8PHu6/qH1SWtGISFGa0n1SmxGIiJGbAAAAwBBAAAD9QSNAAMACQANABxADAQMDA0NCH0HAwMGAgAvMzMRMz8zLzMRMzAxZRUhNQEBIzUBMyMVITUD9fyNA2P9BKgDAqJU/LK/v78DSPv5igQDwMAAAAMABgAABDgEjQAEAAkADQAbQBAIBwMEBgAKDQgBDApyBQF9AD8zKxEXOTAxQQEhASMDAQcjAQERIxEB5AFMAQj+UYjzAU4hhv5RAo7xAgECjPz3Awn9bncDCf2V/d4CIgAAAQATAAAESQSNAAsAFUAKBwoEAQQJBQMAfQA/Mi8zFzkwMUETEyEBASEBAyEBAQE08fQBGv6JAY3+4f7//P7mAYL+iASN/moBlv2+/bUBnv5iAksCQgAEACcAAAXlBI0ABQAKAA8AFQAgQA4SBBABDgQMAQgEBgF9BAAvPzMRMxEzETMRMxEzMDFlEzMXAyMDExcjAQETMwEjAxMXIwM3AavyiwT+kIzFA5j+5QQQxOr+5pfC8guP/gXIA8XE/DcEjfxG0wSN/EcDuftzBI38OcYDycQAAAIACAAABHEEjQAEAAkAD7UHAwUBfQMALz8zETMwMUEBMwEjAwETIwECTQEl//5Is/4BIkm0/kkBLgNf+3MEjfyj/tAEjQABAGn/8AQgBI0AFQAPtQwRBgB9BgAvPxEzMjAxQTMRFAYGIyImJjURMxEUFhYzMjY2NQMu8nzWiYvXevA5aklJaDgEjf0AhrleXrmGAwD9AE1jLi5jTQAAAgAlAAAEGQSNAAMABwARtgYHBwEAfQEALz8ROS8zMDFBESMRIRUhNQKV8QJ1/AwEjftzBI3AwAABAD//8APwBJ0AOQAYQAoKJg82MSsYFA9+AD/MMy/MMxI5OTAxQTQuAicuAzU0PgIzMhYWFSM0JiYjIgYGFRQeAhceAxUUDgIjIi4CNTMUHgIzMjY2AwYXN19IaJ9sN0B2omGN0HPxM2JKR1wtGzxgRWeeajVAd6ZmWrGOVfIlRWA6SV0rATEhNCsmERk/VHJMSXlZMFyhajJQMClBJh4wKCQRGEJZd0xNeVQtLFyPYTRLLxYnQAAAAgB1AAAEOwSNABkAHgAYQAobDQ0MDBoYFwB9AD8yLzM5LzMSOTAxUyEyHgIVFAYGBwchJyEyNjY1NCYmIyMRIyEBNwEVdQHLa6p3P0R8VE3+awIBMEheMC9hSdnyAsL+4P8BJQSNLlmDVl+HWBsqwCxPNDdRLPwzAgQC/gULAAADAE3/LwRsBJ0AAwAZAC8AHEAMAAMDKysKCgIgFX4CAC8/MxI5LzMSOREzMDFlBQclARUUDgIjIi4CNTU0PgIzMh4CBzU0LgIjIg4CFRUUHgIzMj4CAxcBT5v+uAHpS4zBd3TCjkxMjMJ1dsGNTPAnSmtERGpKJydLa0NEa0omr/yE+wI4OIXSlU5OldKFOIXSlk5OltK9OluMYDIyYIxbOlqNYTMzYY0AAAEAdgAABCgEjQAYABO3AgEBDQwPfQ0ALz8zEjkvMzAxQSE1ITI2NjU0JiYjIxEjESEyFhYVFA4CAlj+vgFCTmMvL2NO8fEB4pPQbT54rAGbwC5PMjRYN/wzBI1krXBUiGE0AAACAE7/8ARuBJ0AFQArABC2JwYcEX4GCwA/PzMRMzAxQRUUDgIjIi4CNTU0PgIzMh4CBzU0LgIjIg4CFRUUHgIzMj4CBG5Mi8J1dcKOTU2MwnV2wY1M8SZLakRDa0knJ0trQ0RpSiYCYjiF0pVOTpXShTiF0pZOTpbSvTpbjGAyMmCMWzpajWEzM2GNAAEAdgAABGcEjQAJABG2AwgFAQcAfQA/Mi8zOTkwMUERIwERIxEzAREEZ/L98vHxAg4EjftzAyP83QSN/N0DIwADAHYAAAWPBI0ABgALABAAFkAJAg4KBQwHBAB9AD8yMjIvMzM5MDFTMwEBMwEjATMTESMBMxEjEeHQAVEBUND+MqX9x8wl8QRMzfEEjfyvA1H7cwSN/LP+wASN+3MBQAACAHYAAAOSBI0AAwAHAA+1BgMCBH0CAC8/ETMzMDFlFSE1ExEjEQOS/YlM8b+/vwPO+3MEjQADAHYAAARnBI0AAwAJAA0AF0AMBgcLBQwIBgoBBAB9AD8yLzMXOTAxQREjESEBASc3ARMBNwEBZ/ED3P4Q/ug4xgFOIf5/sAHxBI37cwSN/b7+7+LyAX/7cwIZlf1SAAABACb/8ANlBI0AEwANtBAMBwF9AD8vzDMwMUERMxEUBgYjIiYmNTMUFhYzMjY2AnPybLdyfcBt8ixTOTNJJwFvAx784nmrW0+jfj5PJCxVAAEAhgAAAXgEjQADAAmyAH0BAC8/MDFBESMRAXjyBI37cwSNAAMAdgAABGcEjQADAAcACwAYQAoCAwMECQUIBH0FAC8/MxEzEjkvMzAxQRUhNRMRIxEhESMRA7f9bETxA/HxAp3AwAHw+3MEjftzBI0AAAEAVv/wBEsEnQAqABZACSkqKgUZEH4kBQAvMz8zEjkvMzAxQREOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4CMzI2NzUjNQRLHXa+injFkE1KicB2oM9uDusKOGdRRGtJJSlPc0pjZBX8AmL+MCFMNUuQ0YZJhtGQS2OucTxXMC9eiVtLW4teLykSy60AAAMAdgAAA6EEjQADAAcACwAaQAsHBgYBCgsLAQB9AQAvPxE5LzMROS8zMDFBESMRARUhNQEVITUBZ/EC6v3GAnv9hQSN+3MEjf4RwMAB78DAAAADAD//EwPwBXMAAwAHAEEAKUATBz4+JAgXMwYGMwsCICAXAAAXfgA/My8RMxEzPzMvERI5OTMRMzAxQREjERMRIxElNC4CJy4DNTQ+AjMyFhYVIzQmJiMiBgYVFB4CFx4DFRQOAiMiLgI1MxQeAjMyNjYCe5mZmQEkFzdfSGifbDdAdqJhjdBz8TNiSkdcLRs8YEVnnmo1QHemZlqxjlXyJUVgOkldKwVz/swBNPrU/swBNOohNCsmERk/VHJMSXlZMFyhajJQMClBJh4wKCQRGEJZd0xNeVQtLFyPYTRLLxYnQAADADoAAAQbBJ0AAwAHACYAHUANBAUFASIZfg4CAg0BCgA/MzMRMz8zEjkvMzAxYSE1IQMVITUlFxYGBgcnPgMnAyY+AjMyFhYVIzQmJiMiDgIEG/xiA57S/PEBjAoEJlVCkBwjEwYBCQM1apddirZa8SxMLyg+KRTAAbmQkGj6U5NzJFYHPFVeKgEBaqRyPGS1eE1bKSFAXQAABQAKAAADmgSNAAMABwAMABEAFQAbQAsGBwMCAhEUCgkRfQA/Mz8SOXwvMxjOMjAxQRUhNQUVITUlEzMBIwMBByMBAREjEQNW/PEDD/zxAVf//f6jiasBARuH/qICPfACRJGR2I+PlQKM/PcDCf1udwMJ/ZX93gIiAAACAHYAAAOZBI0AAwAHAA61BwYDfQIKAD8/MzMwMUERIxEhFSE1AWfxAyP9igSN+3MEjcDAAAADAAgAAARxBI0AAwAIAA0AG0AMCAx9AAUFCQIDAwkKAD8zETMRMxEzPzMwMWE1IRUBATMBIwMBEyMBA7D9GwGCASX//kiz/gEiSbT+ScDAA1/8oQSN+3MDXQEw+3MAAwBO//AEbgSdAAMAGQAvABdACgMCAgogFX4rCgsAPzM/MxI5LzMwMUEVITUFFRQOAiMiLgI1NTQ+AjMyHgIHNTQuAiMiDgIVFRQeAjMyPgIDN/5bAtxMi8J1dcKOTU2MwnV2wY1M8SZLakRDa0knJ0trQ0RpSiYCocDAPziF0pVOTpXShTiF0pZOTpbSvTpbjGAyMmCMWzpajWEzM2GNAAIACAAABHEEjQAEAAkADrUBCQoECH0APzM/MzAxQQEzASMDARMjAQJNASX//kiz/gEiSbT+SQNf/KEEjftzA10BMPtzAAADAEYAAANXBI0AAwAHAAsAF0AKBwYGAgoLfQMCCgA/Mz8zEjkvMzAxZRUhNQEVITUBFSE1A1f87wLG/YQCx/zvwMDAAf7BwQHPwMAAAwB2AAAEYwSNAAMABwALABO3CgULBwIAA30APzMzMzMvMzAxQRUhNTMRIxEhESMRA7T9bUbxA+3yBI3AwPtzBI37cwSNAAMARAABA+oEjQADAAcAEAAlQBINCAkDCgYQEA4HfQoCDAMDAgoAPzMRMxEzPzMzETMSFzkwMWUVITUBFSE1ARUBIzUBATUzA+r8uAMj/NkB8P5dpwFC/r6nwL+/A83AwP3OFf27kgG9AauSAAMATwAABVcEjQAVACcAKwAVQAkWAAArfR4MKgoAP80yPzMvMzAxQTMyHgIVFA4CIyMiLgI1ND4CFyIGBgcUFhYzMzI2NjU0JiYjExEjEQKUfXzVnVhYndV8fXzUnVhYndR0Z5RQAU+WZ49nlVBQlWcy8gQZOnWudHazdz08d7J2dLB0O7s5fGNmfzs8gGZjejkBL/tzBI0AAgBPAAAFCQSNABkAHQAfQA4VFBQGBwcNHA4AHR0NfQA/MxEzPxI5ETMzETMwMUEzERQCBCMjIi4CNREzERQeAjMzMjY2NQMRIxEEGPGH/wC1TIbQkEzyJU97V0x3jkDz8QSN/tK8/vqITZbajQEu/tJhk2QzWrCBAS77cwSNAAADAF4AAASBBJ0ALAAwADQAJ0ATLTQKLjMKKBISKRERMjIxCgYdfgA/Mz8zETMRMzMRMz8zPzMwMUE1NC4CIyIOAhUVFB4CFxUuAzU1ND4CMzIeAhUVFA4CBzU+AgM1IRUhNSEVA48hR2xNS2xGIR08VjhnrX9GR4fFfX7FiUdGfatmTmQw4gHN+/IBywJkKkp6WjExWnpKKlmKZkMSdQxYkcF0Imm5jVFRjbhpI3TAkVgNdRlnp/4TwcHBwQAAAwAj/+wFVASNAAMABwAjABxADRcWCyANDQMECgUCA30APzMzPxI5LzM/MzAxQRUhNQERMxEDNT4CMzIWFhUUDgIjNTI+AjU0JiYjIgYGA9X8TgFc81osdIdHi890QXytbTZVOx81alE9dnEEjcDA+3MEjftzAfu+EyATWbSLZJBcK7kULEo1TWAuER8AAAIAT//wBEMEnQADACsAF0AKAAEBCR0UfigJCwA/Mz8zEjkvMzAxQRUhNQEzDgIjIi4CNTU0PgIzMhYWFyMuAiMiDgIVFRQeAjMyNjYCw/43AlbyCXnYmXe9hUdIiL12m9R2DPEGNmxYRGZFIx9CZ0dVbDoCp8DA/t13tmdOkc+BToHPk01punhBYzgvXolaT1iJXjEvYAAAAwAkAAAHFwSNABEAKQAtACBADygpKRwsHQEtfR8cCgsICgA/Mz8zPzMzMxI5LzMwMUEzAw4EIyM1Nz4ENyUyFhYVFA4CIyERMxEzMjY1NCYmIyE1AxUhNQEb8hQFHztfiF0yJio9KhoQBAQ/kNBvP3isbP4c8vJxbTBiTP68bP3DBI3994fRmmIwyAMDIEFomWhgX6lxVIxnOASN/DN1TDJSM8ABlcDAAAADAHYAAAcaBI0AFwAbAB8AIUAPFxYWGxoaHgsffQ0KCh4KAD8zETM/MxI5LzMzLzMwMUEyFhYVFA4CIyERMxEzMjY1NCYmIyE1BxUhNRMRIxEFS5DPcEB4q2z+G/LzcWwwYUz+u1/9fETxAvhfqXFUjGc4BI38M3VMMlIzwFvAwAHw+3MEjQAAAwAlAAAFVQSNAAMABwAbABlACxgNDQMTBAoFAgN9AD8zMz8zEjkvMzAxQRUhNQERMxEDNT4CMzIWFhURIxE0JiYjIgYGA9b8TwFc8Vksc4dFjNF08jVrUD12cASNwMD7cwSN+3MB+74TIBNVu5n+qgFWVmYtER8ABAB2/qEEYgSNAAMABwALAA8AG0AMDwt9AwcHDgoCAgoKAD8zLxEzMxEzPzMwMWURIxElFSE1ExEjESERIxEC7PIBuv1tRvED7PGz/e4CEg3AwAPN+3MEjftzBI0AAAIAdgAABCkEjQAXABsAG0AMAgEBDQsOChsaGg19AD8zETM/MxI5LzMwMUEhFSEyFhYVFAYjIxEjESEyPgI1NCYmNzUhFQJa/rwBRExiMG1x8/EB5GyreEBwz8n9cQLpwC5OM1BqA837czVjilZzpVnmvr4AAwAn/q8FFASNABAAFgAeACNAEBodHQkXCgocFAkKFhERAH0APzIRMz8zMzMRMxEzLzMwMUEzAw4EByM1Mz4DNxMhESMRIQEhESMRIREjAULvCgQrSmBuOkcjKkEuGQNJAv7x/fP+qATs8fz28gSN/mKT4KVzTBi/LmB6rn4BmvtzA8388/3vAVH+sAAFABsAAAYqBI0AAwAJAA0AEwAXADVAGRQXFxEMCwsHBxERBg4ODwoCAhUKCQMDD30APzMRMz8zETMSOS8zMxEzETMRMxEzETMwMUERIxEhASEnMxMTATcJAiETMwcnASEBA5vxA1/+df7UEbT4E/7owAGC+5f+ewEd97QRlv7p/tUBhgSN+3MEjf1L1QHg+3MCAZj9ZwHYArX+INUp/f8CmQACAEP/8APqBJ0AHgA+AB1ADR8CAgE+PhU0KgsLFX4APzM/MxI5LzMzETMwMUEjNTMyNjY1NCYmIyIGBhUjND4CMzIeAhUUDgIlMzIeAhUUDgIjIi4CNTMeAjMyNjY1NC4CIyMCObmRTV4qLWBPNVk38UN4n11pqXhCP3CX/u+5bKJtNkeCrmhRoYVR8QQ6YDtRaDIeO1g6jQIsfSdFLypFKh08Lk55VCwoT3dPQ3FTLUYtUm9BVH9VKyRQhF81QyAqSTAsQSoVAAMAdgAABG0EjQADAAcACwAbQAwAAwoHCwoBAgUFCH0APzMRMzM/MzMzMzAxdwEXAQEzESMBMxEjtgLFsP08AhTy8vz78fFeBC9e+9EEjftzBI37cwAAAwB2AAAEQQSNAAMACQANAB9ADgwLCwcHBgYCCQN9CgIKAD8zPzMSOS8zETMRMzAxQREjESEBISczARMBNwEBaPIDqf4k/u0gwgEzEP6nqgHbBI37cwSN/UvVAeD7cwIBmf1mAAMAJAAABFYEjQADAAcAGQAYQAsTEAoHAgMDCH0GCgA/PzMRMzM/MzAxQRUhNSERIxEhMwMOBCMjNTc+BDcDmP3DAvvy/bfyFQYfPF6IWzImKjwqGhAEBI3AwPtzBI3994fRmmIwyAQFIEBol2gAAgAf/+wEQQSNABIAFwAXQAoBF30VFhYODgcLAD8zETMRMz8zMDFBASEBDgIjIiYnNxYWMzI2NjcDARMHAQIsAQ4BB/5qI1SEbRhBDQILOw40PykStwEJXK3+PQHYArX8eU2BTAMCvgICKEInA1H9sv7uSAOoAAQAdv6vBSUEjQAFAAkADQARAB1ADRENfQUJCRALCAICCAoAPzMvETMzMxEzPzMwMWUDIxEjNTMVITUTESMRIREjEQUlE96EBP1tRvED7fLA/e8BUcDAwAPN+3MEjftzBI0AAgBDAAAEGASNAAMAFwATtxQJCQIDDn0CAC8/MxI5LzMwMUERIxETFQ4CIyImJjURMxEUFhYzMjY2BBjyWStzfz2U2XXyNWtQPnVxBI37cwSN/f++Ex8UVbyYAVz+pFZlLhIeAAQAdgAABg8EjQADAAcACwAPABlACwsHBw8QCgYGAw59AD8zMxEzPzMRMzAxZRUhNQERIxEhESMRIREjEQVg+6UCtvIDRvL8SvHAwMADzftzBI37cwSN+3MEjQAABQB2/q8G0ASNAAUACQANABEAFQAnQBIRDQ0VfQQQAgIQEAwMExMJCAoAPzMzETMRMxEzLxEzPzMRMzAxZQMjESM1MxUhNQERIxEhESMRIREjEQbQEt2EA/ulArbyA0by/ErxwP3vAVHAwMADzftzBI37cwSN+3MEjQACAAkAAAUkBI0AAwAaABdACgYFBQ8SChEBAH0APzIyPzM5LzMwMVMVITUBIRUhMhYWFRQGIyMRIxEhMjY2NTQmJgkBywGA/rwBRExjMG1y8/EB5JDQcHDQBI3AwP5rwDNSMkx1A837c2KtcHGpXwD//wB2AAAFogSNBCYCIwAAAAcB/gQqAAAAAQB2AAAEKQSNABYAFUAJFRYWCgwJCgp9AD8/MxI5LzMwMUEyFhYVFAYGIyERMxEzMjY1NCYmIyE1AlqQz3Bwz5D+HPHzcW0wYkz+vAL4X6lxcK1iBI38M3VMMlIzwAAAAgA9//AEMQSdAAMAKwAXQAoCAQEcCCcLExx+AD8zPzMSOS8zMDFBITUhAR4CMzI+AjU1NC4CIyIGBgcjPgIzMh4CFRUUDgIjIiYmJwOG/jgByP2qBzltVUdmQh8jRWZEV2w2BvINddWadr6HSEeEvXeZ2HkKAefA/t1GYC8xXolYT1qJXi84Y0F4umlNk8+BToHPkU5ntncAAAQAdv/wBkAEnQADAAcAHQAzAB1ADiQZfi8OCwMCAgYHfQYKAD8/EjkvMz8zPzMwMUEVITUTESMRARUUDgIjIi4CNTU0PgIzMh4CBzU0LgIjIg4CFRUUHgIzMj4CApr+ikPxBcpMjMF2dcKNTUyMwnV2woxN8SdKa0REakonJ0xqRERqSScCpMDAAen7cwSN/dU4hdKVTk6V0oU4hdKWTk6W0r06W4xgMjJgjFs6Wo1hMzNhjQAAAgBCAAAEDwSNAAMAIwAZQAsjAAQEGRsWfRkBCgA/Mz8zEjkvMzMwMUEBIQEFIS4CJy4CJy4CNTQ+AjMhESMRIyIGFRQWFjMhAnX+0P79ATUB+P6RFg0MFgMKCgNhfz89daVpAc3y3GtjK1xHATACS/21AkuNAQcKBAEQEAEYW31MUYFaL/tzA81gSjJLKQAAAwALAAAEBQSNAAMABwALABtADAsKCgMCBgcHA30CCgA/PzMRMxESOS8zMDFBESMRIRUhNQEVITUB0/IDJP2KARv9YQSN+3MEjcDA/gGmpgAGABv+rwZ4BI0AAwAHAA0AEQAXABsAO0AcAg4BAQ4OBhsYGBUSEhAPDAkJEwYGGQoNBwcTfQA/MxEzPzMREjkvMzMzMxEzMxEzETMRMy8RMzAxQSMRMwERIxEhASEnMxMTATcJAiETMwcnASEBBnjOzv0j8QNf/nX+1BG0+BP+6MABgvuX/nsBHfe0EZb+6f7VAYb+rwIQA877cwSN/UvVAeD7cwIBmP1nAdgCtf4g1Sn9/wKZAAQAdv6vBH4EjQADAAcADQARACdAEhAPDwsKCgYNB30CDgEBDg4GCgA/MxEzLxEzPzMSOS8zMxEzMDFBIxEzAREjESEBISczARMBNwEEfszM/OryA6n+JP7tIMIBMxD+p6oB2/6vAhADzvtzBI39S9UB4PtzAgGZ/WYABAB2AAAE8QSNAAMABwANABEAKUATEA8PCgALCwoDAwoKBg0HfQ4GCgA/Mz8zEjkvMy8RMxEzETMRMzAxQTMRIwMRIxEhASEnIQETATcBAa6enkbyBFn+JP49IAFyATQP/qeqAdsDjf1+A4L7cwSN/UvVAeD7cwIBmf1mAAQAIQAABVMEjQADAAcADQARACFADxAPDwsKCg4GCg0HBwMAfQA/MjIRMz8zOS8zMxEzMDFTIRUhJREjESEBISczARMBNwEhAcv+NQJZ8QOp/iT+7B/CATMQ/qipAdoEjcDA+3MEjf1L1QHg+3MCAZn9ZgAAAQBO/+sFoASmAEQAG0AMAAEBLxgLJCMjOg1+AD8zMxEzPzMzLzMwMWUVIiQuAjU1ND4CMzIeAhUVFA4CIyIuAjU1ND4CMxUiDgIVFRQeAjMyPgI1NTQuAiMiDgIVFRQeAgWgm/7205RPOm2ZXmKcbzpnu/6YlO6oWkaCs246XEAhNWaXYGSlekMWLEMtLEUvGFKe6a6/Nmyf04Iod7qCREGAunhGjeqrXlGd45IugM2RTMcvXIZYJWWbajQ6cqhuNFJ1SiQmTXBLLX6zbzUA//8ABgAABDgEjQQmAe4AAAAHAkEAPv7TAAIAE/6vBIYEjQADAA8AIkARCw4IBQQKBg99AgoBAQoKDQoAPzMRMy8RMz8zEhc5MDFBIxEzARMTIQEBIQEDIQEBBIbNzfyu8fQBGv6JAY3+4f7//P7mAYL+iP6vAhADzv5qAZb9vv21AZ7+YgJLAkIAAAUAI/6vBjEEjQAFAAkADQARABUAIkAQEQ0NFBV9EBIMCQQIAgIIEgA/My8RMzMzPz8zMxEzMDFlAyMRIzUzFSE1ExEjESERIxEjFSE1BjET3YQD/WxH8gPt8bT8WsD97wFRwMDAA837cwSN+3MEjcDAAAMAQwAABBgEjQADAAcAGwAfQA4AGBgNAwMNDQYHEn0GCgA/PzMSOS8zLxEzETMwMUEzESMBESMRExUOAiMiJiY1ETMRFBYWMzI2NgHjnZ0CNfJZK3N/PZTZdfI1a1A+dXEDQv1+A837cwSN/f++Ex8UVbyYAVz+pFZlLhIeAAIAdgAABEoEjQADABcAFEAJDxIUCQkBfQASAD8/OS8zPzAxcxEzEQM1PgIzMhYWFREjETQmJiMiBgZ28Vkscn89ldh18TZqUT12cASN+3MCAr4TIBNVupn+ogFdVmYtER4AAQAO//AFrASkADQAG0AMGBgdHRERIgt+LQALAD8yPzM5LzMRMy8wMUUiLgI1NTQ+AjMyHgIVFSEiLgI1MxQWFjMhNTQmJiMiDgIVFRQeAjMyNjcXDgIDzoncnFNUlMNxfseJSPv2Z5hkMb8vXkgDGUSBX0ZvTignU4dhapUxQBdllhBMj8l+dHzHj0xHisqDmDxvml1FZjgXWoBFMVt+ToRLe1oxKxS2DSUdAAEATf/wBH8EpAArABVACREUFBkLCyQAfgA/Mj8zOS8zMDFBMh4CFRUUDgIjIi4CNTUhFSEVFBYWMzI+AjU1NC4CIyIGByc+AgI1htmZUlOVxHB/xolIA379dEKDXkZvTSknVIdgapUwQBdnmQSkTI/JfnR7yI9MSIrKgpnAF1mBRDBbf06CS3xaMSoVtg0mHAAAAgBD/+wD6gSNAAcAJgAbQAwIBQUEJiYdEwsHAH0APzI/MzkvMzMRMzAxUyEXASM1ASEBMzIeAhUUDgIjIi4CNTMeAjMyNjY1NCYmIyNsA1QB/mSdAQ791gEcsWyjbDZHgq5oUaGFUfEDOmJATWYyNWlNhQSNmv5cdAEK/ug5ZH5GWodaLSVRhWA1RiIrTzc5TyoAAAMATv/wBG4EnQAVACQANAAbQA4LJWotHWotLQsAFmoACwAvLysSOS8rKzAxQTIeAhUVFA4CIyIuAjU1ND4CFyIGBgcGBgchJiYnLgIDMjY2NzY2NyEWFhceAwJedsGNTEyLwnV1wo5NTYzCdU10SgwBAQICNgECAQxKc0xOc0gMAgEB/csBAgEJL0heBJ1OltKFOIXSlU5OldKFOIXSlk7AQX1aCA8JCRIIWXtB/NJBflkIDwgIEQhCaUYlAAAEADoAAAQbBJ0AAwAHAAsAKgAhQA8GBwMCAgkmHX4SCgoRCRIAPzMzETM/MxI5LzPOMjAxQRUhNQUVITUBITUhARcWBgYHJz4DJwMmPgIzMhYWFSM0JiYjIg4CA0n88QMP/PED4fxiA579qwoEJlVCkBwjEwYBCQM1apddirZa8SxMLyg+KRQCvJGR64+P/i/AAiH6U5NzJFYHPFVeKgEBaqRyPGKvdUlXJiFAXQADAEX/8AOuBJ4AIwAnACsAHUANJyYmKisrBxkSfgAHCwA/Mz8zEjkvMzMvMzAxZTI2NxcGBiMiLgI1NTQ+AjMyFhcHJiYjIg4CFRUUHgITFSE1BRUhNQLMO1szGThsPnW5gURDgLl1P2k8FTRgO0NgPx4fP2HE/PgDCPz4rw8NvA8QQn+5d8B5voNDEBC7EAwpUHZNwkxyTScCVJGR7pCQAAAEAHYAAAfCBJ4AAwAVACcAMQApQBIrMC4tJAkJMS59Ki0KGxISAgMALzMzfC8zGD8zPzMzLzMREjk5MDFBFSE1AzU0NjYzMhYWFRUUBgYjIiYmNxUUFhYzMjY2NTU0JiYjIgYGAREjAREjETMBEQeG/cY6VZlqappUU5ppa5pVqCZQPDtNJydOPDtPJv6t8v3y8fECDgFhkJABpUlil1ZWl2JJYZdWVpeqSTdYMjJYN0k3VzMzVwEH+3MDI/zdBI383QMjAAACACgAAASvBI0AGAAcABtACxscAgEBDgwPfQ4KAD8/MxI5fC8zGM4yMDFBITUhMjY2NTQmJiMjESMRITIWFhUUDgIHFSE1Auj9QALASV8uLl9J+/EB7I7MbT52qVH9JwGesjdXMTNWNfwzBI1hqm1UiWQ2TrKyAAACADf/9QKpAyAAGQAzABlAChsAABkaGggQLCQALzPMMjkvMzMRMzAxQTMyNjY1NCYjIgYVIzQ2NjMyFhYVFAYGIyMVNTMyFhYVFAYGIyImJjUzFBYzMjY1NCYmIwEOVys4HTdAMUO2UIZPW4pNR31UdXVdhEVUkVpLjVu3SD1BPyNAKwHRGSweJDcpJUdkNDNkSjlYMSlSK1hGSmg2MWpWJzg5KyYuFQACADYAAAK/AxUABwALABdACQMHBwEBBgUICgAvzDIyOS8zETMwMUEVIScBMwcHAREjEQK//YEKAW+PnbABdrYBOZR2Afr64gHc/OsDFQABAFD/9QKtAxUAIQASth8JCQQDGREALzPMMjkvMzAxUycTIRUhBzY2MzIWFhUUBgYjIiYmJzMWFjMyNjU0JiMiBvSRNAHs/qkWEUssV3hAQoVnTIlXA7YCQzRENEVCNTYBXSQBlJGaBhY9clFHfE43aEgtKEs1OUYcAAEATv/1ArgDIgAtABO2ExwcAwAMJAAvM8wyOX0vMzAxQTMVIyIGBhUVFBYWMzI2NjU0JiMiBgYHJz4CMzIWFhUUBgYjIiYmNTU0PgICFh0LWIRIIDsoJTcgQjwpPyQBMAE5bkxTcDlLh1tdj1FDe6YDIpQvb2F2MUIgIzkkOT4eLBYjLV9BRHdNTXxHSY1oNXCmbjYAAAEANwAAAq0DFQAGAAyzBQEGAgAvzDIyMDFBFQEjASE1Aq3+q8ABVf5KAxVm/VECg5IABABL//UCqgMgAA8AHwAvAD0AF0AKDCQ7AxQUNCwcBAAvM8wyOS8XMzAxZRQGBiMiJiY1NDY2MzIWFgc0JiYjIgYGFRQWFjMyNjYTFAYGIyImJjU0NjYzMhYWBzQmJiMiBhUUFhYzMjYCqk+JV1aKUFCJVleJULUgNyQkNh4eNyQkNx+iSX9UU4FJSYFSU4FJtxcuITA2GC8gMTTZTGUzM2VMRmI2NmI2HysXFysfHi0XFy0Bdz9dMzNdP0liMzNiVRwnFi8qGikXMgAAAQBH//YCowMgAC4AE7YSGxsKIwEtAC8zzDI5fC8zMDF3MzI2NjU1NCYmIyIGBhUUFhYzMjY2NRcUBgYjIiYmNTQ2NjMyFhYVFRQOAiMj1Q1ZdjwfNSUlNh0cOSkpOR43Pmg/UnY9S4haWYhOPnSlaA+HKWNWmDE+HiY/JiU5IB4rEx8yWjk/dlJOgU1HkGw1c6RpMgAAAQCNAosDLQMxAAMACLEDAgAvMzAxQRUhNQMt/WADMaamAAMAmARNAqYGmgADAA8AGwAZQAkTDQ0HAQMDGQcALzMzfC8YzREzETMwMUE3MwcFNDYzMhYVFAYjIiY3FBYzMjY1NCYjIgYBGarj9/7pbk5Na2tNTm5jNCUkMTEkJTQF18PD3U1kZE1MYWFMJTExJSczMwAABAB2AAADtgSNAAMABwALAA8AG0AMCwoKBg8OB30DAgYKAD8zMz8zMxI5LzMwMWUVITUTESMRARUhNQEVITUDtv1lTPEC6v27Apn9Z7+/vwPO+3MEjf4tv78B08DAAAQADP5KBBgETgASACQAWwBfADNAGl1fBnIlJhgYD0BBQS5TUw8PBUo3D3IhBQdyACsyKzIROS85ETMzETMRMxI5OSsyMDFTNTQ2NjMyFhYVFRQOAiMiJiY3FRQWFjMyNjY1NTQmJiMiBgYTFwYGFRQWFjMzMhYWFRQOAiMiLgI1NDY2NxcOAhUUHgIzMj4CNTQmJiMjIiYmNTQ2NgEXISdGcsuGiMtwQHelZYfMcvA0X0JAXjM0X0BAXzQcWhtAIjojs36xXkiNyoN1tHs+X4xFOSI7JB4+XUFNc0wmIU9FyEl6Sz9YAuoC/oALAs4WaqRcXKRqFkuEZDhipHsWLlIzM1IuFjFQMTFQ/rQyDjYxHyIOQoVjO3xoQCxOZDdWekkNVgUsQikdNSgYHjA4GyM3ICdUQ0NcPQKElZUAAAQAVv/rBFoETgAVACsALwAzABdADDAKLQYcEQtyJwYHcgArMisyPz8wMVM1ND4CMzIeAhcVDgMjIi4CNxUUHgIzMj4CNzUuAyMiDgIFEzMLAjMTVjhtoWlmlWc+DQ09aJZnZ6BuOPIaOFxBOlQ6IggGITpVOkFcOhoB403ba2lUvXIB+xV+0ppUT4/GeDh1wI1NTo7BiBVHelwzN194QjREfWQ6PGmLQgIe/eL95AIc/eQAAAIAmQAABPAFsAAZAC4AH0APJggbGhoCAQEODA8Ccg4IAD8rMhI5LzMzETM/MDFBISchMjY2NTQmJiMhESMRITIWFhUUBgYPAjceAhUVFBYWFxUhLgI1NTQmJgLi/mQBAWNheTk2c1z+3foCKKPgclikcRZzMau/TgwfHP7/HhsHNmsCWMY1ZEhGajn7GAWwYruIYZBgHC8XhQFhp210IVNMGBsaYmEYcExtOgADAJkAAAUsBbAAAwAJAA0AIEAQCggJAgwLCwcGBgIDAnICCAA/KxI5LzMzETM/PzAxQREjESEBISczARMBNwEBk/oEZv2w/p0i+gGoM/4pogJiBbD6UAWw/MLaAmT6UAKYwfynAAADAIEAAAQzBgAAAwAJAA0AHEAOCwcGBgIJBnIDAHIKAgoAPzMrKxI5LzMzMDFBESMRAQEhJzMBEwE3AQFx8AOH/kb+3EXxARgt/q6dAc0GAPoABgD+Ov2hvwGg+8YB+qr9XAAAAwCZAAAFCwWwAAMACQANABpADgYLBwgMBQIJAwJyCgIIAD8zKzISFzkwMUERIxEhASEnMwETATcBAZP6BE/9ff7OCm8CGCP9juICyAWw+lAFsP0GdgKE+lAC2Gb8wgAAAwCBAAAEHwYYAAMACQANACBAEAwLCwcGBgIJBnIDAXIKAgoAPzMrKxI5LzMzETMwMUERIxEBASEnMwETATcBAXHwA3P+Ev77HI0BXS3+UbYCHAYY+egGGP4i/cGeAaH7xgIXgP1pAAACAHYAAAQrBI0AGQAdABZACRsaDwIBDg99AQAvPzMRMxEzMjAxYSE3ITI2NjU1NC4CIyE1ITIeAhUVFAYEAREjEQHv/vACAQ5zkkUnUHtU/ucBGX3Rl1OR/v/+zvG/VaJ0OleHXC/AUJPMfDil+osEjftzBI0AAQBP//AEQwSdACcAEbYZFRB+JAAFAC/MMz/MMzAxQTMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4CMzI2NgNQ8gl52Jl3vYVHSIi9dpvUdgzxBjZsWERmRSMfQmdHVWw6AYR3tmdOkc+BToHPk01punhBYzgvXolaT1iJXjEvYAAAAgB2AAAEDASNABkAMQAoQBMcGykZAgIBGyYBASYbAw0MD30NAC8/MxIXOS8vLxEzEjk5ETMwMUEhJyEyNjY1NCYmIyMRIxEhMh4CFRQGBgcDITchMjY2NTQmJiMjNyEXNhYWFRQOAgJY/r4CAR9BWi8uXETI8QGsbKl4P0eSdFT+hWIBGUZbLCdWRfYBATg3b4pBPHKmAf2mIkEvNUQf/DMEjSdOeVJHekwE/cS/KEUtMkkppkECUYBFVX1TKQAAAwAIAAAEkQSNAAQACQANABxADA0ABgMMDAEHA30FAQAvMz8zEjkvEjk5MzAxQQEjATMBASczAQEVITUCWv6i9AHVogEe/qAlpQHU/v39ZgOe/GIEjftzA6Dt+3MBsLW1AAABAJAEbQGeBikACgAKsgWAAAAvGs0wMVM1NDY2NxcGBhUHkChBJIEcJAEEbYVAeWIcUDV1SHoAAAIAdQTUAwMGfAAPABMAErUSEwoADQUALzN83DLWGM0wMUEzFAYGIyImJjUzFBYzMjYnJzMXAlatT5NkZZNQrEZWU0bJqrN3BbFBYzk5Y0EtRUU3wcEAAvyeBLz+2AaJABcAGwAdQAwAFRUFGRsbCRERDAUALzMzETMzLzMRMxEzMDFBFxQGBiMiJiYjIgYVJzQ2NjMyFhYzMjYlNzMH/nFnKkowNkU+Kx8raCpKMC1IRikeLf73gb60BZ0dMFIyJCQyJhwwUjMkIzI/0tIAAgB6BOcEewaKAAYACgAUtwgHBwUBgAQGAC8zGs05My/NMDFTJTMFIycHJRMzA3oBHp0BH82hoAHEmtfXBOf29o6OmwEI/vgAAv9RBNsDUwZ/AAYACgAXQAkHQAgIAwaAAgQALzMazTkzLxrNMDFBBSMnByMlJRMjAwI0AR/NoKDNAR7+kZqZ2AXR9o+P9q7++AEIAAIAeQToBAYGyAAGABoAH0ANERIIQBoJCAgDBoACBAAvMxrNOTMRMzMaEMwyMDFBBSMnByMlBSMnPgI1NCYmIzcyHgIVFAYHAj4BFb6vsL0BFAH2iAgrNRkjOyUHRGdHJFIxBd/3oKD3cnoDDBgTGRsMZxcrOyY+OgcAAgB5BOgDUwbNAAYAHgAlQBAIBwcQGAxAFBMTHAwMBoAEAC8azTIRMzMRMxoQzTIyETMwMUEFIycHIyU3FxQGBiMiJiYjIgYVJzQ2NjMyFhYzMjYCLgElvq+wvQEl8VolQiowQDonGydaJUIqKEJCJRooBdLqj4/q+x4nSC0iIiwdGChILyIhLgAAAwB2AAADmQXEAAMABwALABtADAIKCgsLBwMDB30GCgA/PzMvETMRMxEzMDFBESMRAREjESEVITUDmfH+v/EDI/2KBcT+CQH3/sn7cwSNwMAAAAIAdQTTAwMGfAAPABMAErUREwAKDQUALzN83DIY1s0wMUEzFAYGIyImJjUzFBYzMjYnNzMHAlatT5NkZZNQrEZWU0bgeLOqBbBBZDg4ZEEtRUU4wcEAAgB1BNUC/QcHAA8AJQAoQBEbHBwRJRISEREJDQUACQkFEAA/M3wvMxEzETMYLzMRMxEzLzMwMUEzFAYGIyImJjUzFBYzMjYnIyc+AjU0LgIjNzIeAhUUBgYHAlKrT5BlY5NOqkdTUkdKnAkxPB0XKTcgB094UCkrQyYFsEFjNzdjQS1CQkVzAgwWEhAWDQVeFSY3IiUwGAUA//8ATAKNAqkFuAYHAeIAAAKY//8ANgKYAr8FrQYHAjsAAAKY//8AUAKNAq0FrQYHAjwAAAKY//8ATgKNArgFugYHAj0AAAKY//8ANwKYAq0FrQYHAj4AAAKY//8ASwKNAqoFuAYHAj8AAAKY//8ARwKOAqMFuAYHAkAAAAKYAAEAaf/rBSEFxQApABVAChoWEQNyJgAFCXIAK8wzK8wzMDFBMw4CIyIuAzU1NBI2NjMyFhYXIy4CIyIOAhUVFB4DMzI2NgQl+w+M9a9vwZxwPFyo5omv+I8P+w5KiGpWimQ1I0JedUZohUoB2pXefEF9sOCDN6QBCr9lfeKWXodISYm/dzlfooBaL0aGAAABAGn/6wUiBcUALQAbQA0tLCwFGhYRA3ImBQlyACsyK8wzEjkvMzAxQREOAiMiLgM1NTQSNjYzMhYWFyMuAiMiDgIVFRQeAzMyNjY3ESE1BSIdiNmYdM2nekFdqueJt/OGEvcMS4doVo1nOChLaINLUHNIEP7cAuH92ihiRkJ8suKFJ6gBD8BleNKHTHhFSozEeClho4JbLxsoEgEfuwAAAgCZAAAFFAWwABsAHwAStxwPEAJyAh0AAC8yMisyMjAxYSE3ITI+AjU1NC4CIyE1ITIEFhIVFRQCBgQBESMRAkz+vAIBOHWwdjw8da1w/rcBU5oBAb1nZ73++v6p+sdKiblvLXK6hUjIZrz+/J0rnf78u2YFsPpQBbAAAAIAaf/rBW4FxQAZADEAELchFANyLQcJcgArMisyMDFBFRQOAyMiLgM1NTQ+AzMyHgMHNTQuAyMiDgIVFRQeAzMyPgIFbj5xn8RwbsOgdD4+c6DCbnDFn3I++SVEYXpHVpBoOiZFYnhFWpBnOALuLH3etIJGRoK03n0sfd21gkZGgrXdqS5an4JdMk6NvnEuW6CCXjJOjcAAAwBp/wQFbgXFAAMAHQA1ABtADSUYA3IAAwMxCwlyAQIALzMrMjIRMysyMDFlAQcBARUUDgMjIi4DNTU0PgMzMh4DBzU0LgMjIg4CFRUUHgMzMj4CA9EBdKP+lAI4PnGfxHBuw6B0Pj5zoMJucMWfcj75JURhekdWkGg6JkVieEVakGc4wv7RjwEtArcigOC1gUVFgbXggCKB4LWCRUWCteCjJF6ig1wxTIzCdiReooNdMU2MwwABAJYAAALqBI0ABgAVQAkDBAQFBQZ9AgoAPz8zLzMRMzAxQREjEQU1JQLq8f6dAjUEjftzA3B8yNEAAQBrAAAELwSfACAAF0AKEBAMFX4DICACEgA/MxEzPzMzLzAxZRUhNQE+AjU0JiYjIgYGFSM0NjYzMh4CFRQOAgcFBC/8WgHqPUEYJ1dJRGc78XjUi2ykbzgjQ2A//u2/v5wBqDVRSicqSzA1YkR0uW0yW3xKOWZfYDT7AAEAD/6jA/cEjQAfABpACwYAHh4DFg8FAgN9AD8zMy8zEjkvMzMwMUEBITUhFwEeAhUUDgIjIiYnNxYWMzI2NjU0JiYjIwFNAVD9uwN0Af6bbrVsWaDagWjEaDZKqllyo1dNnnpMAlQBecCN/n0Pdb6AgciJRjM0sygwVphgZYRAAAACADT+xASIBI0ABwALABZACQYEC30KAwcHAgAvMxEzLz8zMzAxZRUhJwEzAwEBESMRBIj7swcCqL3P/moCofG/wJID/P6S/aADzvo3BckAAAEAZ/6gBCEEjAAnABZACSQJCQIaEwUCfQA/My8zEjkvMzAxQScTIRUhAzY2NzYeAhUUDgIjIiYnNxYWMzI+AjU0LgIjIgYGAVLIVgMp/ZouKXdSaKRzO0SHzIhu0F1KOqRiT3hQKCJCYkE+UjQBaREDEsz+oBgfAQFDgLZxa76TUzo7ri02NFx4RUBtUi0bMwAAAQBC/sQEFgSNAAYAD7UBBQUGfQMALz8zETMwMUEVASMBITUEFv258wI8/SoEjYX6vAUJwAAAAgB2BM4C/AbaAA8AJwApQBEREBAZISEVHRwcJRUVAAkNBQAvM80yMnwvMzMRMxEzGC8zMxEzMDFBMxQGBiMiJiY1MxQWMzI2ExcUBgYjIiYmIyIGFSc0NjYzMhYWMzI2AlCsT5BkY5FPq0RUU0QiaCtJMTVFPiwfK2cpSjEsSEUrHiwFr0JmOTlmQi1ERAFYHjBSMiQkMiUbMFMzJCMyAAEAYv6aAVMAswADAAixAQAAL80wMWURIxEBU/Gz/ecCGQAFAE7/8AZuBJ0AKQAtADEANQA5ADFAGDg5OTF9Fi0tFzAKNTQ0JhsBBgYmfhEbCwA/Mz8zETMREjkvMz8zMxEzPzMRMzAxQQciLgIjIg4CFRUUHgIzMj4CMxciBgYjIi4CNTU0PgIzMhYWARUhNRMRIxEBFSE1ARUhNQPnGSBqcl8VQ2tJJydLa0MXYHRnHRpOlH0qdcKOTU2MwnUqf5UC0v1mS/EC6v28Apn9ZwSNwAQHBTJgjFs6Wo1hMwUFBb4ICE6V0oU4hdKWTggI/DK/vwPO+3MEjf4tv78B08DAAAEAbv60BFAEoQA7ABS3ABUfHzULKTUALy8zEjkvMzIwMUUyPgI1NTQuAiMiDgIVFB4CMzI+AjU3FAYGIyIuAjU0PgIzMh4CFRUUDgMjIiYnNxYWAepViWI0JUVhPTZaQiQgQVw8S3BKJWV3yHlppnU+SIGtZ3G8i006apKxZUiWRi8xaY1ChsuJ9VeDWCwuVnlKQXNYMitHUycKjMBiSIW5cHa+iEpIj9WNz5Ttsnc7Hh6yEh0AAf+n/ksBiwDOABEACrINBgAAL8wyMDF3MxEUBgYjIiYnNxYWMzI2NjWZ8laebiQ8Ig4TOhYpOh7O/vR5qFYHCsEGBihPOgD//wA4/qMEIASNBAYCZykA//8AaP6gBCIEjAQGAmkBAP//ACz+xASABI0EBgJo+AD//wBiAAAEJgSfBAYCZvcA//8AX/7EBDMEjQQGAmodAP//ADT/6wRXBKAEBgKA1AD//wBs/+wEMgW5BAYAGvkA//8AWf60BDsEoQQGAm7rAP//AGf/7AQmBcQGBgAcAAD//wDlAAADOQSNBAYCZU8A////rv5LAZIEOgQGAJwAAP///67+SwGSBDoGBgCcAAD//wCQAAABgQQ6BgYAjQAA////+v5eAYEEOgYmAI0AAAEGAKTRCgALtgEEAgAAQ1YAKzQA//8AkAAAAYEEOgYGAI0AAAADAHb/6wQZBJ0AAwAWADEAKUAUDyYmDSMjCRsvC3IEAAACEwl+AgoAPz8zEjkvMysyETkvMzMRMzAxQREjERcjNDY2MzIWFwEnNRMmJiMiBgYTNxYWMzI2NjU0JiYjIzU3Mh4CFRQGBiMiJgFi7OzsXbmLic5W/qiGzB1MNT5PJUZFGUovNk0pNm1QUm9pp3Y+Z7JvQ3QC7f0TAu0CkMFhdF/+ZANxAQIYJT5v/O62ESAvVDc7RyGdBypSek96qFYdAAIAYP/rBIMEoAAVACsADrUcEX4nBgsAPzM/MzAxQRUUDgIjIi4CNTU0PgIzMh4CBzU0LgIjIg4CFRUUHgIzMj4CBINQj8FwcMKQUVCQwXBwwZBR8SxOaj0+aE8rLE9pPj5pTSsCThGU35RLS5TflBGU35VKSpXftDFjkV8vL1+RYzFjkmAuLmCSAAEAOQAAA+oFsAAGABNACQEFBQYEcgMMcgArKzIRMzAxQRUBIwEhNQPq/dPyAi39QQWwhPrUBPDAAAADAH3/7AREBgAABAAaAC8AGUAOIRYHcisLC3IECnIAAHIAKysrMisyMDFTMxEHIwEVFA4CIyIuAic1PgMzMh4CBzU0LgIjIg4CBxUeAjMyPgJ98SDRA8c7c6NnZZZlPg0NPmWVZGilcjvxH0BiREBePyQGCT1uVUNiPx8GAPrn5wInFXbJlVJNi8B0Q3fDjUxPksuQFUyCYTYrTGc7tUl8SzhigAAAAQBP/+wEAAROACcAGUAMHRkZFAdyBAQACQtyACsyMi8rMi8yMDFlMjY2NzMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4CAkE7YT0D4wR6xnh8vH4/QH66fILFcgTjAzdgQ0ljOxkZO2OrMFQ3aaxlVZbEcCNwxZZVZ7d5PGE6O2V9QyNDfmQ7AAADAE7/7AQVBgAABAAaAC8AGUANIQQEFgtyKwsHcgEAcgArKzIrMi8yMDFlETMRIwE1ND4CMzIeAhcVDgMjIi4CNxUUHgIzMjY2NzUuAyMiDgIDI/LS/QtBdqNkYpRnPg4NP2iUY2KjdkHyIUJiQVJtPwsGJkBdPkFjQyHgBSD6AAIRFXzLkk9MjcJ3RHPBi01SlMmLFUmBYTdIfEu2O2ZMKzZhggAAAwBO/lUEFQROABMAKQA+ABtADzAlC3I6GgdyDgYPcgAGcgArKzIrMisyMDFBMxEUDgIjIiYnNxYWMzI2NjURATU0PgIzMh4CFxUOAyMiLgI3FRQeAjMyNjY3NS4DIyIOAgNF0EOBunZLuUwxPIdKX3o7/Ss/dqNlaZZjOg4OPWaWZWOjdj/yIUJiQVVsPAwHJT5dQEJjQiEEOvwVebyCQysvqyEoR4toAvr+zRV7y5JPTI3Cd0N0wIxNUpXJixVKgGI3SXtMtTtmTCs2YYIAAAIASf/sBFMETgAVACsAELccEQtyJwYHcgArMisyMDFTNTQ+AjMyHgIVFRQOAiMiLgI3FRQeAjMyPgI1NTQuAiMiDgJJSYi+dXe/iEhIh792dr+ISfEkRWhEQ2dGIiNFaEREZkUkAhEXdcmVU1OVyXUXdciVU1OVyIwXSYJjODhjgkkXSIFkOTlkgQAAAwB9/mAEQwROAAQAGgAvABlADiEWB3IrCwtyAwZyAg5yACsrKzIrMjAxQREjETMBFRQOAiMiLgInNT4DMzIeAgc1NC4CIyIOAgcVHgIzMj4CAW7x2ALuPXOiZmWXaD8NDT9olmRmpHQ88SJEY0FAXUAkBgw8bVRBYkMiA2r69gXa/e0VdsmVUkuJu3BRd8KNTE+Sy5AVTIJhNitMZjvCSHhHOGSBAAMATv5gBBQETgAEABoALwAZQA4hFgtyKwsHcgQOcgMGcgArKysyKzIwMUERNzMRATU0PgIzMh4CFxUOAyMiLgI3FRQeAjMyNjY3NS4DIyIOAgMiIdH8Oj91pWZllWc+Dg0+aJZmZKV1P/IhQ2NBVW89CwYlQF9AQWRDIv5gBQPX+iYDsRV7y5NPTI3Cd0RzwYtNUpTJixVKgWM4Sn5LtjtmTis3YoMAAAEAUf/sBAoETgAqABlADBMSEgAZCwdyJAALcgArMisyETkvMzAxRSIuAjU1ND4CMzIeAhUVITUhNTQmJiMiDgIVFRQeAjMyNjcXBgYCcn3IkExKhLRpdK5zOfy8AlYtYlE8XT8hKlJ7UlOVNDcytxRQkMNzKn3Jj01Jh7pwf60aQm5CMlyDUSpJfV00MCGjJkcAAwBQ/lUEAwROABIAKAA9ABtADy8kC3I5GQdyDQYPcgAGcgArKzIrMisyMDFBMxEUBgYjIiYnNxYWMzI2NjURATU0PgIzMh4CFxUOAyMiLgI3FRQeAjMyNjY3NS4DIyIOAgMz0HffnUavRzI3e0VgeTv9PzptnmVplWQ5Dg49ZpVlZJ1tOvIaOlxBVWs6CwYjPV1AQV06GwQ6/Aqe3XQlKawdIUSHYwMG/swVfMuST0yNwndDdMCMTVKUyYsVSn9iN0l7TLU7ZkwrN2GCAAACADT+TQRbBEoAAwAlABlADA4VAQEVHwQHcgMGcgArKzIvMy8RMzAxQQEjASUyHgIXAR4CFxY2NwcGBicuAycBLgIjIgYHJzY2BCz9IvUC3/2CUGlFLBIBlhAmLx0OMQ4iFDsZPFpCNBf+fRAzQisMKg0EHUUEOvomBdoQNlRdJ/xnJjsmAwEBAcAHBgIDNFRpOAN2K0MnBAG2CAsA//8AYQAAArcFtQQGABW3AAABAF//7gS9BJ0AQQAXQAs4OBAifhkKMwALcgArMj8/MzkvMDFFIi4CNTQ2NjclNjY1NCYjIgYVFBYWFwEhAS4CNTQ2NjMyFhYVFAYGBwUOAhUUFhYzMj4CNTMUBgcGBgcGBgIBYZtsOjBZPQEHMydBOzs8JT8mAqD+9v3LOVgzUphoaZhUK0kt/uAhJAwrUz1hl2o30lhLDhgRUNESLlJwQERnVSmzIj4hKj5DKiA+QCf9TwJEOmJoQ018SUp/UDVdTh/GGC4rFClAIzxtlVqCzk4OGww/RgADAAUAAAOeBI0AAwAHAAsAHUANCAkJCwoKBgd9AwIGCgA/MzM/EjkvMzMvMzAxZRUhNRMRIxEBFQU1A579ikvxAfL9kb+/vwPO+3MEjf6hkbuRAAAG/+wAAAYEBI0AAwAHAAsAEAAUABgAM0AYCgsLGBgPBwYUEwYTBhMND30DAgIXFw0KAD8zETMRMz8SOTkvLxEzETMRMxEzETMwMWUVITUBFSE1ARUhNQcBIQEzExUhNQETIwMGBP2EAhL90QJu/YRf/fP++wJtoK79hwKQKu8rvr6+AgC+vgHPvr5y++UEjf03vLwCyftzBI0AAgB2AAAD0QSNAAMAGQAXQAoPEBABfQUEBAAKAD8yLzM/My8zMDFzETMRJzUzMjY2NTQmJiMjNTMyFhYVFAYGI3bxUetOYi8vYk7q6pLQbm7QkgSN+3PkwS5TNDJVNcBiqm5yqV0AAwBO/8cEbgS7ABUAKwAvABtACy8vHBF+LS0nBgtyACsyMnwvGD8zM3wvMDFBFRQOAiMiLgI1NTQ+AjMyHgIHNTQuAiMiDgIVFRQeAjMyPgITASMBBG5Mi8J1dcKOTU2MwnV2wY1M8SZLakRDa0knJ0trQ0RpSibs/I6fA3QCYjiF0pVOTpXShTiF0pZOTpbSvTpbjGAyMmCMWzpajWEzM2GNAuv7DAT0AAAEADQAAATaBI0AAwAHAAsADwAbQAwCA4AODw8LB30KBgoAPzM/MzMvMxrMMjAxQRUhNRMRIxEhESMRBRUhNQPQ/WxE8QPx8QFL+1oCncDAAfD7cwSN+3MEjZanpwAAAgB2/ksEZwSNAAkAGwAfQA8XEA9yCQMGfQgKCgICBQoAPzMRMxEzPzMzKzIwMUERIwERIxEzARERMxUUBgYjIiYnNxYWMzI2NjUEZ/L98vHxAg7yVZ9vIzwiDhM6FSo5HwSN+3MDI/zdBI383QMj+7iDeahWBwrBBgYoTzr//wBQAg4CYQLOBgYAEQAAAAMAFwAABPAFsAAaAB4AIgAjQBECAQEdIiEhHQ4PDx4Cch0IcgArKzIRMxE5LzMRMxEzMDFhITchMjY2NTU0LgIjITUhMh4CFRUUDgIBESMRARUhNQJZ/skCATWHt101Z5Vh/roBRpHwr15esPP+vvsCBf1gx3bcmE92tnxAyGG2/p1Nnf61YQWw+lAFsP2EpqYAAwAXAAAE8AWwABoAHgAiACNAEQIBAR0iISEdDg8PHgJyHQhyACsrMhEzETkvMxEzETMwMWEhNyEyNjY1NTQuAiMhNSEyHgIVFRQOAgERIxEBFSE1Aln+yQIBNYe3XTVnlWH+ugFGkfCvXl6w8/6++wIF/WDHdtyYT3a2fEDIYbb+nU2d/rVhBbD6UAWw/YSmpgAD//UAAAQYBgAAAwAaAB4AGUANHh0WCgdyAwByEQIKcgArMisrMsQyMDFBESMREyc+AzMyHgIVESMRNCYmIyIOAgEVITUBiPDGTgE9b5xfUIFeMfItVj5BY0IhATf9YAYA+gAGAPxFAXC+jU0sYZtv/UkCuU5cKTRadgLnpqYAAAMALQAABLQFsAADAAcACwAVQAoDCgsGBwJyAQhyACsrMi8zMjAxQREjESEVITUBFSE1Auv5AsL7eQOM/WAFsPpQBbDIyP4IpqYAA//r/+wCiwVDAAMAFQAZAB1ADgoRC3IYGRkCAgQEAwZyACsyLzIRMy8zKzIwMUEVITUTMxEUFhYzMjY3FwYGIyImJjUBFSE1Amz9nrDxHTQjGS4OAR5PM1OASAHR/WAEOrCwAQn76DI1EgYDuAkOO4ZvAcGmpgD//wARAAAFPwc3BiYAJQAAAQcARAEbATcAC7YDEAcBAWFWACs0AP//ABEAAAU/BzcGJgAlAAABBwB1AcIBNwALtgMOAwEBYVYAKzQA//8AEQAABT8HNwYmACUAAAEHAJ4AwgE3AAu2AxEHAQFsVgArNAD//wARAAAFPwcqBiYAJQAAAQcApQDFATcAC7YDHAMBAWtWACs0AP//ABEAAAU/BwQGJgAlAAABBwBqAOQBNwANtwQDIwcBAXhWACs0NAD//wARAAAFPweRBiYAJQAAAQcAowFYAWwADbcEAxkHAQFHVgArNDQA//8AEQAABT8HsQYmACUAAAEHAkIBWAEXABK2BQQDGwcBALj/srBWACs0NDT//wBm/jkE6wXEBiYAJwAAAQcAeQHL//oAC7YBKAUAAApWACs0AP//AJQAAARNBz4GJgApAAABBwBEAOUBPgALtgQSBwEBbFYAKzQA//8AlAAABE0HPgYmACkAAAEHAHUBjAE+AAu2BBAHAQFsVgArNAD//wCUAAAETQc+BiYAKQAAAQcAngCNAT4AC7YEEwcBAXdWACs0AP//AJQAAARNBwsGJgApAAABBwBqAK4BPgANtwUEJQcBAYNWACs0NAD////LAAABoAc+BiYALQAAAQcARP+TAT4AC7YBBgMBAWxWACs0AP//AKUAAAJ8Bz4GJgAtAAABBwB1ADoBPgALtgEEAwEBbFYAKzQA////ygAAAn4HPgYmAC0AAAEHAJ7/OgE+AAu2AQcDAQF3VgArNAD///++AAAChwcLBiYALQAAAQcAav9bAT4ADbcCARkDAQGDVgArNDQA//8AlAAABRcHKgYmADIAAAEHAKUA8QE3AAu2ARgGAQFrVgArNAD//wBl/+wFHQc4BiYAMwAAAQcARAEzATgAC7YCLhEBAU9WACs0AP//AGX/7AUdBzgGJgAzAAABBwB1AdoBOAALtgIsEQEBT1YAKzQA//8AZf/sBR0HOAYmADMAAAEHAJ4A2gE4AAu2Ai8RAQFaVgArNAD//wBl/+wFHQcsBiYAMwAAAQcApQDdATkAC7YCOhEBAVlWACs0AP//AGX/7AUdBwUGJgAzAAABBwBqAPwBOAANtwMCQREBAWZWACs0NAD//wCA/+wEvwc3BiYAOQAAAQcARAEPATcAC7YBGAABAWFWACs0AP//AID/7AS/BzcGJgA5AAABBwB1AbYBNwALtgEWCwEBYVYAKzQA//8AgP/sBL8HNwYmADkAAAEHAJ4AtgE3AAu2ARkAAQFsVgArNAD//wCA/+wEvwcEBiYAOQAAAQcAagDXATcADbcCASsAAQF4VgArNDQA//8ACAAABNkHNgYmAD0AAAEHAHUBjAE2AAu2AQkCAQFgVgArNAD//wBW/+wD+QYABiYARQAAAQcARACmAAAAC7YCPQ8BAYxWACs0AP//AFb/7AP5BgAGJgBFAAABBwB1AU0AAAALtgI7DwEBjFYAKzQA//8AVv/sA/kGAAYmAEUAAAEGAJ5NAAALtgI+DwEBl1YAKzQA//8AVv/sA/kF9AYmAEUAAAEGAKVQAQALtgJJDwEBllYAKzQA//8AVv/sA/kFzQYmAEUAAAEGAGpvAAANtwMCUA8BAaNWACs0NAD//wBW/+wD+QZaBiYARQAAAQcAowDjADUADbcDAkYPAQFyVgArNDQA//8AVv/sA/kGegYmAEUAAAEHAkIA4v/gABK2BAMCSA8AALj/3bBWACs0NDT//wBO/jkD8QROBiYARwAAAQcAeQFB//oAC7YBKAkAAApWACs0AP//AFH/7AQKBgAGJgBJAAABBwBEAJsAAAALtgEuCwEBjFYAKzQA//8AUf/sBAoGAAYmAEkAAAEHAHUBQgAAAAu2ASwLAQGMVgArNAD//wBR/+wECgYABiYASQAAAQYAnkIAAAu2AS8LAQGXVgArNAD//wBR/+wECgXNBiYASQAAAQYAamMAAA23AgFBCwEBo1YAKzQ0AP///7QAAAGIBfcGJgCNAAABBwBE/3z/9wALtgEGAwEBnlYAKzQA//8AkAAAAmUF9wYmAI0AAAEGAHUj9wALtgEEAwEBnlYAKzQA////tAAAAmgF9wYmAI0AAAEHAJ7/JP/3AAu2AQcDAQGpVgArNAD///+oAAACcQXEBiYAjQAAAQcAav9F//cADbcCARkDAQG1VgArNDQA//8AegAAA/oF9AYmAFIAAAEGAKVaAQALtgIqAwEBqlYAKzQA//8ATv/sBDwGAAYmAFMAAAEHAEQAsQAAAAu2Ai4GAQGMVgArNAD//wBO/+wEPAYABiYAUwAAAQcAdQFXAAAAC7YCLAYBAYxWACs0AP//AE7/7AQ8BgAGJgBTAAABBgCeWAAAC7YCLwYBAZdWACs0AP//AE7/7AQ8BfQGJgBTAAABBgClWwEAC7YCOgYBAZZWACs0AP//AE7/7AQ8Bc0GJgBTAAABBgBqeQAADbcDAkEGAQGjVgArNDQA//8Ad//sA/kGAAYmAFkAAAEHAEQArAAAAAu2Ah4RAQGgVgArNAD//wB3/+wD+QYABiYAWQAAAQcAdQFSAAAAC7YCHBEBAaBWACs0AP//AHf/7AP5BgAGJgBZAAABBgCeUwAAC7YCHxEBAatWACs0AP//AHf/7AP5Bc0GJgBZAAABBgBqdAAADbcDAjERAQG3VgArNDQA//8ADP5LA94GAAYmAF0AAAEHAHUBGwAAAAu2AhkBAQGgVgArNAD//wAM/ksD3gXNBiYAXQAAAQYAaj0AAA23AwIuAQEBt1YAKzQ0AP//ABEAAAU/BuMGJgAlAAABBwBwAL0BOQALtgMQAwEBplYAKzQA//8AVv/sA/kFrQYmAEUAAAEGAHBIAwALtgI9DwEB0VYAKzQA//8AEQAABT8HHgYmACUAAAEHAKEA8AE3AAu2AxMHAQFTVgArNAD//wBW/+wD+QXnBiYARQAAAQYAoXsAAAu2AkAPAQF+VgArNAAABAAR/lQFPwWwAAQACQANACMAK0AVDQwMAxYdBgACBwMCcg4PDwUFAghyACsyETMRMysyEjk5LzMSOS8zMDFBASEBMwEBJzMBARUhNQEXDgIVFBYzMjY3FwYGIyImNTQ2NgLL/k3++QIkqAFa/kwTqQIm/uP86AOCcy5KKSAnHiwPFxlOPFh7LmgE7vsSBbD6UATuwvpQAhzHx/4eOh49RSgeJxEHiw8dZmI0ZV0AAwBW/lQD+QROABsAOgBQACtAFx46Og9DSg9yJzELcjs8PBkKcgkFDwdyACsyMisyETMrMisyEjkvMzAxZRE0JiYjIgYGFSM0PgIzMhYWFREUFhcVIyYmExcjIg4CFRQWFjMyNjY3Fw4DIyImJjU0PgIzARcOAhUUFjMyNjcXBgYjIiY1NDY2At4qVUA7VjDwPnakZnq9bRUU9xETIwKtQ2ZEIihNN0pvQAJODDpdgVRqpl5Bf7h2ARlzL0kqICcfLA4XGU48WHouaNkCBDpULihEK0B4XjZSpXz+H0p1KxAneQHylRkwRCsrRyg9WShrKV5VNlWRXFaFWi/9qDoePUUoHicRB4sPHWZiNGVdAP//AGb/7ATrB0sGJgAnAAABBwB1AcQBSwALtgEoEAEBbVYAKzQA//8ATv/sA/EGAAYmAEcAAAEHAHUBLgAAAAu2ASgUAQGMVgArNAD//wBm/+wE6wdLBiYAJwAAAQcAngDFAUsAC7YBKxABAXhWACs0AP//AE7/7APxBgAGJgBHAAABBgCeLwAAC7YBKxQBAZdWACs0AP//AGb/7ATrBygGJgAnAAABBwCiAakBUwALtgExEAEBglYAKzQA//8ATv/sA/EF3QYmAEcAAAEHAKIBEwAIAAu2ATEUAQGhVgArNAD//wBm/+wE6wdLBiYAJwAAAQcAnwDbAUsAC7YBLhABAXZWACs0AP//AE7/7APxBgAGJgBHAAABBgCfRQAAC7YBLhQBAZVWACs0AP//AJQAAATSBz4GJgAoAAABBwCfAGEBPgALtgIlHgEBdVYAKzQA//8AUP/sBVgGAgQmAEgAAAEHAdUEBAUCAAu2AzkBAQAAVgArNAD//wCUAAAETQbqBiYAKQAAAQcAcACHAUAAC7YEEgcBAbFWACs0AP//AFH/7AQKBa0GJgBJAAABBgBwPAMAC7YBLgsBAdFWACs0AP//AJQAAARNByUGJgApAAABBwChALoBPgALtgQVBwEBXlYAKzQA//8AUf/sBAoF5wYmAEkAAAEGAKFwAAALtgExCwEBflYAKzQA//8AlAAABE0HGwYmACkAAAEHAKIBcQFGAAu2BBkHAQGBVgArNAD//wBR/+wECgXeBiYASQAAAQcAogEmAAkAC7YBNQsBAaFWACs0AAAFAJT+VARNBbAAAwAHAAsADwAlAClAFAoLCxgfDg8PBwJyEBERAwICBghyACsyETMyETMrMhEzLzM5LzMwMWUVITUTESMRARUhNQEVITUBFw4CFRQWMzI2NxcGBiMiJjU0NjYETfz7R/sDVP1gAwD9AAIdcy9JKiAoHiwOGBlPO1l6LmjHx8cE6fpQBbD9oMTEAmDIyPqKOh49RSgeJxEHiw8dZmI0ZV0AAAIAUf5yBAoETgArAEEAJUATEhMTCzQ7DnIZCwdyLC0kJAALcgArMhE5OSsyKzISOS8zMDFFIi4CNTU0PgIzMh4CFRUhNSE1LgIjIg4CFRUUHgIzMjY3Fw4CNxcOAhUUFjMyNjcXBgYjIiY1NDY2All4wYdISoS0aXSuczn8vAJWAi9gUDxdPiEnTGxFV4gyfyNwoQ9zLkopICceLA8XGU48WHsuaBRPjsBvKH/Ok05OjcJ1Z60TQXJGM2CHVChHeVozRkB7M106azoePkMoHyYQB4oPHWViNGVeAP//AJQAAARNBz4GJgApAAABBwCfAKMBPgALtgQWBwEBdVYAKzQA//8AUf/sBAoGAAYmAEkAAAEGAJ9YAAALtgEyCwEBlVYAKzQA//8Aa//sBPIHSwYmACsAAAEHAJ4AxgFLAAu2AS8QAQF4VgArNAD//wBS/lUEDAYABiYASwAAAQYAnkQAAAu2A0IaAQGXVgArNAD//wBr/+wE8gcyBiYAKwAAAQcAoQD0AUsAC7YBMRABAV9WACs0AP//AFL+VQQMBecGJgBLAAABBgChcQAAC7YDRBoBAX5WACs0AP//AGv/7ATyBygGJgArAAABBwCiAasBUwALtgE1EAEBglYAKzQA//8AUv5VBAwF3QQmAEsAAAEHAKIBKAAIAAu2A0gaAQGhVgArNAD//wBr/fYE8gXEBiYAKwAAAQcB1QHm/pIADrQBNQUBAbj/mLBWACs0//8AUv5VBAwGpQQmAEsAAAEHAk8BMAB8AAu2Az8aAQGYVgArNAD//wCUAAAFFwc+BiYALAAAAQcAngDmAT4AC7YDDwsBAXdWACs0AP//AHoAAAP6B18GJgBMAAABBwCeABoBXwALtgIeAwEBJlYAKzQA////tAAAApAHMQYmAC0AAAEHAKX/PQE+AAu2ARIDAQF2VgArNAD///+dAAACeQXrBiYAjQAAAQcApf8m//gAC7YBEgMBAahWACs0AP///9EAAAJ4BuoGJgAtAAABBwBw/zQBQAALtgEGAwEBsVYAKzQA////uwAAAmIFpAYmAI0AAAEHAHD/Hv/6AAu2AQYDAQHjVgArNAD////dAAACZwclBiYALQAAAQcAof9oAT4AC7YBCQMBAV5WACs0AP///8YAAAJQBd4GJgCNAAABBwCh/1H/9wALtgEJAwEBkFYAKzQA//8AGP5aAaAFsAYmAC0AAAEGAKTvBgALtgEFAgAAAFYAKzQA//////5UAZAF1gYmAE0AAAEGAKTWAAALtgIRAgAAAFYAKzQA//8AnwAAAaQHGwYmAC0AAAEHAKIAHgFGAAu2AQ0DAQGBVgArNAD//wCl/+wGKQWwBCYALQAAAAcALgJEAAD//wB8/ksDkQXWBCYATQAAAAcATgIKAAD//wAv/+wEswc1BiYALgAAAQcAngFvATUAC7YBFwEBAWpWACs0AP///67+SwJqBd4GJgCcAAABBwCe/yb/3gALtgEVAAEBglYAKzQA//8AlP5JBRYFsAQmAC8AAAEHAdUBnP7lAA60AxcCAQC4/+ewVgArNP//AH3+NAQ3BgAGJgBPAAABBwHVATL+0AAOtAMXAgEBuP/UsFYAKzT//wCUAAAEJAczBiYAMAAAAQcAdQAsATMAC7YCCAcBAVxWACs0AP//AIwAAAJfB5AGJgBQAAABBwB1AB0BkAALtgEEAwEBcVYAKzQA//8AlP4GBCQFsAQmADAAAAEHAdUBb/6iAA60AhECAQG4/5ewVgArNP//AFn+BgF+BgAEJgBQAAABBwHVABL+ogAOtAENAgEBuP+XsFYAKzT//wCUAAAEJAWxBiYAMAAAAQcB1QILBLEAC7YCEQcAAAFWACs0AP//AIwAAALgBgIEJgBQAAABBwHVAYwFAgALtgENAwAAAlYAKzQA//8AlAAABCQFsAYmADAAAAAHAKIBzf3Q//8AjAAAAusGAAQmAFAAAAAHAKIBZf2t//8AlAAABRcHNwYmADIAAAEHAHUB7gE3AAu2AQoGAQFhVgArNAD//wB6AAAD+gYABiYAUgAAAQcAdQFXAAAAC7YCHAMBAaBWACs0AP//AJT+AgUXBbAEJgAyAAABBwHVAeD+ngAOtAETBQEBuP+XsFYAKzT//wB6/gYD+gROBCYAUgAAAQcB1QFG/qIADrQCJQIBAbj/l7BWACs0//8AlAAABRcHNwYmADIAAAEHAJ8BBQE3AAu2ARAJAQFqVgArNAD//wB6AAAD+gYABiYAUgAAAQYAn20AAAu2AiIDAQGpVgArNAD///+jAAAD+gYDBiYAUgAAAQcB1f9cBQMAC7YCIAMBATpWACs0AP//AGX/7AUdBuUGJgAzAAABBwBwANUBOwALtgIuEQEBlFYAKzQA//8ATv/sBDwFrQYmAFMAAAEGAHBSAwALtgIuBgEB0VYAKzQA//8AZf/sBR0HHwYmADMAAAEHAKEBCAE4AAu2AjERAQFBVgArNAD//wBO/+wEPAXnBiYAUwAAAQcAoQCGAAAAC7YCMQYBAX5WACs0AP//AGX/7AUdBzcGJgAzAAABBwCmAWABOAANtwMCLBEBAUVWACs0NAD//wBO/+wEPAX/BiYAUwAAAQcApgDdAAAADbcDAiwGAQGCVgArNDQA//8AlAAABN8HNwYmADYAAAEHAHUBcwE3AAu2Ah4AAQFhVgArNAD//wB9AAAC9AYABiYAVgAAAQcAdQCyAAAAC7YCFwMBAaBWACs0AP//AJT+BgTfBbAEJgA2AAABBwHVAXH+ogAOtAInGAEBuP+XsFYAKzT//wBS/gcCuQROBCYAVgAAAQcB1QAL/qMADrQCIAIBAbj/mLBWACs0//8AlAAABN8HNwYmADYAAAEHAJ8AigE3AAu2AiQAAQFqVgArNAD//wA2AAAC/QYABiYAVgAAAQYAn8gAAAu2Ah0DAQGpVgArNAD//wBL/+wEjgc4BiYANwAAAQcAdQGVATgAC7YBOg8BAU9WACs0AP//AEn/7APHBgAGJgBXAAABBwB1ATYAAAALtgE2DgEBjFYAKzQA//8AS//sBI4HOAYmADcAAAEHAJ4AlgE4AAu2AT0PAQFaVgArNAD//wBJ/+wDxwYABiYAVwAAAQYAnjcAAAu2ATkOAQGXVgArNAD//wBL/j4EjgXEBiYANwAAAQcAeQGg//8AC7YBOisAABNWACs0AP//AEn+NQPHBE4GJgBXAAABBwB5AT7/9gALtgE2KQAAClYAKzQA//8AS/37BI4FxAYmADcAAAEHAdUBjv6XAA60AUMrAQG4/6CwVgArNP//AEn98gPHBE4GJgBXAAABBwHVASv+jgAOtAE/KQEBuP+XsFYAKzT//wBL/+wEjgc4BiYANwAAAQcAnwCsATgAC7YBQA8BAVhWACs0AP//AEn/7APHBgAGJgBXAAABBgCfTQAAC7YBPA4BAZVWACs0AP//AC3+AAS0BbAGJgA4AAABBwHVAXz+nAAOtAIRAgEBuP+NsFYAKzT//wAK/fwCdQVDBiYAWAAAAQcB1QDG/pgADrQCHxEBAbj/obBWACs0//8ALf5DBLQFsAYmADgAAAEHAHkBjgAEAAu2AggCAQAAVgArNAD//wAK/j8CowVDBiYAWAAAAQcAeQDZAAAAC7YCFhEAABRWACs0AP//AC0AAAS0BzYGJgA4AAABBwCfAJwBNgALtgIOAwEBaVYAKzQA//8ACv/sAyIGfgQmAFgAAAEHAdUBzgV+AA60AhoEAQC4/6iwVgArNP//AID/7AS/ByoGJgA5AAABBwClALkBNwALtgEkCwEBa1YAKzQA//8Ad//sA/kF9AYmAFkAAAEGAKVVAQALtgIqEQEBqlYAKzQA//8AgP/sBL8G4wYmADkAAAEHAHAAsAE5AAu2ARgLAQGmVgArNAD//wB3/+wD+QWtBiYAWQAAAQYAcE0DAAu2Ah4RAQHlVgArNAD//wCA/+wEvwceBiYAOQAAAQcAoQDkATcAC7YBGwABAVNWACs0AP//AHf/7AP5BecGJgBZAAABBwChAIAAAAALtgIhEQEBklYAKzQA//8AgP/sBL8HkQYmADkAAAEHAKMBTAFsAA23AgEhAAEBR1YAKzQ0AP//AHf/7AP5BloGJgBZAAABBwCjAOgANQANtwMCJxEBAYZWACs0NAD//wCA/+wEvwc2BiYAOQAAAQcApgE7ATcADbcCARYAAQFXVgArNDQA//8Ad//sBDAF/wYmAFkAAAEHAKYA2AAAAA23AwIcEQEBllYAKzQ0AAACAID+jAS/BbAAFQArABtADR4lAQsCchcWEREGCXIAKzISOTkrMi8zMDFBMxEUBgYjIiYmNREzERQWFjMyNjY1AxcOAhUUFjMyNjcXBgYjIiY1NDY2A8X6kPeYnfaN+kiEWlqDSGNzLkkqICceLA8XGU48WHsuaAWw/DOm4HFx4KYDzfwzaYdAQIdp/o86Hj5EKB4nEQeLDx1lYjVlXQAAAwB3/lQD+QQ6AAQAGwAxACFAESQrD3IBEQZyHB0dBAQYCwtyACsyMhEzETMrMisyMDFlETMRIxM3FA4CIyIuAjURMxEUHgIzMjY2ExcOAhUUFjMyNjcXBgYjIiY1NDY2Awfy5BRRMGScbU+EXzTxHDBAJGd3M0dzL0kqICgeLA4YGU87WXouaP8DO/vGAeACbbeHSy5gmmsCu/1DO08wFFGK/rA6Hj1FKB4nEQeLDx1mYjRlXf//AC8AAAbmBzcGJgA7AAABBwCeAakBNwALtgQZFQEBbFYAKzQA//8AIwAABcgGAAYmAFsAAAEHAJ4BDAAAAAu2BBkVAQGrVgArNAD//wAIAAAE2Qc2BiYAPQAAAQcAngCMATYAC7YBDAIBAWtWACs0AP//AAz+SwPeBgAGJgBdAAABBgCeHAAAC7YCHAEBAatWACs0AP//AAgAAATZBwMGJgA9AAABBwBqAK0BNgANtwIBHgIBAXdWACs0NAD//wBQAAAEjgc3BiYAPgAAAQcAdQGHATcAC7YDDg0BAWFWACs0AP//AFEAAAPBBgAGJgBeAAABBwB1AR8AAAALtgMODQEBoFYAKzQA//8AUAAABI4HFAYmAD4AAAEHAKIBbAE/AAu2AxcIAQF2VgArNAD//wBRAAADwQXdBiYAXgAAAQcAogEEAAgAC7YDFwgBAbVWACs0AP//AFAAAASOBzcGJgA+AAABBwCfAJ4BNwALtgMUCAEBalYAKzQA//8AUQAAA8EGAAYmAF4AAAEGAJ82AAALtgMUCAEBqVYAKzQA/////AAAB04HQgYmAIEAAAEHAHUCwQFCAAu2BhkDAQFsVgArNAD//wBI/+sGhgYBBiYAhgAAAQcAdQJ1AAEAC7YDXw8BAY1WACs0AP//AGn/ogUiB4AGJgCDAAABBwB1AeMBgAALtgM0FgEBllYAKzQA//8ATv91BDwF/QYmAIkAAAEHAHUBMv/9AAu2AzAKAQGLVgArNAD///+lAAAEKwSNBiYCSwAAAAcCQf8Y/2v///+lAAAEKwSNBiYCSwAAAAcCQf8Y/2v//wAlAAAEGQSNBiYB8wAAAAYCQTO6//8ACAAABJEGHgYmAk4AAAEHAEQAwAAeAAu2AxAHAQFrVgArNAD//wAIAAAEkQYeBiYCTgAAAQcAdQFnAB4AC7YDDgMBAWtWACs0AP//AAgAAASRBh4GJgJOAAABBgCeZx4AC7YDEwMBAWtWACs0AP//AAgAAASRBhIGJgJOAAABBgClah8AC7YDGwMBAWtWACs0AP//AAgAAASRBesGJgJOAAABBwBqAIgAHgANtwQDFwMBAWtWACs0NAD//wAIAAAEkQZ4BiYCTgAAAQcAowD9AFMADbcEAxkDAQFRVgArNDQA//8ACAAABJEGmAYmAk4AAAAHAkIA/P/+//8AT/4+BEMEnQYmAkwAAAAHAHkBbf////8AdgAAA7YGHgYmAkMAAAEHAEQAkwAeAAu2BBIHAQFsVgArNAD//wB2AAADtgYeBiYCQwAAAQcAdQE6AB4AC7YEEAcBAWxWACs0AP//AHYAAAO2Bh4GJgJDAAABBgCeOx4AC7YEFgcBAWxWACs0AP//AHYAAAO2BesGJgJDAAABBgBqXB4ADbcFBBkHAQGEVgArNDQA////qAAAAXwGHgYmAf4AAAEHAET/cAAeAAu2AQYDAQFrVgArNAD//wCGAAACWQYeBiYB/gAAAQYAdRceAAu2AQQDAQFrVgArNAD///+nAAACWwYeBiYB/gAAAQcAnv8XAB4AC7YBCQMBAXZWACs0AP///5wAAAJlBesGJgH+AAABBwBq/zkAHgANtwIBDQMBAYRWACs0NAD//wB2AAAEZwYSBiYB+QAAAQcApQCLAB8AC7YBGAYBAXZWACs0AP//AE7/8ARuBh4GJgH4AAABBwBEAM4AHgALtgIuEQEBW1YAKzQA//8ATv/wBG4GHgYmAfgAAAEHAHUBdQAeAAu2AiwRAQFbVgArNAD//wBO//AEbgYeBiYB+AAAAQYAnnUeAAu2AjERAQFbVgArNAD//wBO//AEbgYSBiYB+AAAAQYApXgfAAu2AjERAQFvVgArNAD//wBO//AEbgXrBiYB+AAAAQcAagCXAB4ADbcDAjURAQF0VgArNDQA//8Aaf/wBCAGHgYmAfIAAAEHAEQAswAeAAu2ARgLAQFrVgArNAD//wBp//AEIAYeBiYB8gAAAQcAdQFaAB4AC7YBFgsBAWtWACs0AP//AGn/8AQgBh4GJgHyAAABBgCeWx4AC7YBGwsBAWtWACs0AP//AGn/8AQgBesGJgHyAAABBgBqfB4ADbcCAR8LAQGEVgArNDQA//8ABgAABDgGHgYmAe4AAAEHAHUBMQAeAAu2Aw4JAQFrVgArNAD//wAIAAAEkQXLBiYCTgAAAQYAcGEhAAu2AxADAQGwVgArNAD//wAIAAAEkQYFBiYCTgAAAQcAoQCVAB4AC7YDEwMBAV1WACs0AAAEAAj+VASRBI0ABAAJAA0AIwAhQA8NDAwDFh0IA30PDgUFARIAPzMRMzM/My8zEjkvMzAxQQEjATMBASczAQEVITUBFw4CFRQWMzI2NxcGBiMiJjU0NjYCWv6i9AHVogEe/qAlpQHU/v39ZgL1cy5KKSAnHiwPFxlOPFh7LmgDnvxiBI37cwOg7ftzAbC1tf6KOh49RSgeJxEHiw8dZmI0ZV0A//8AT//wBEMGHgYmAkwAAAEHAHUBZwAeAAu2ASgQAQFbVgArNAD//wBP//AEQwYeBiYCTAAAAQYAnmgeAAu2AS0QAQFbVgArNAD//wBP//AEQwX7BiYCTAAAAQcAogFMACYAC7YBMRABAXBWACs0AP//AE//8ARDBh4GJgJMAAABBgCffh4AC7YBLhABAWRWACs0AP//AGEAAAQrBh4GJgJLAAABBgCf8x4AC7YCJB0BAXRWACs0AP//AHYAAAO2BcsGJgJDAAABBgBwNSEAC7YEEgcBAbBWACs0AP//AHYAAAO2BgUGJgJDAAABBgChaB4AC7YEFQcBAV5WACs0AP//AHYAAAO2BfsGJgJDAAABBwCiAR8AJgALtgQZBwEBgFYAKzQAAAUAdv5UA7YEjQADAAcACwAPACUAI0AQGB8LCgoGDw4HfREQEAUGEgA/MzMRMz8zMxI5LzMvMzAxZRUhNRMRIxEBFSE1ARUhNQEXDgIVFBYzMjY3FwYGIyImNTQ2NgO2/WVM8QLq/bsCmf1nAcVzL0kqICgeLA4YGU87WXouaL+/vwPO+3MEjf4tv78B08DA+606Hj1FKB4nEQeLDx1mYjRlXQD//wB2AAADtgYeBiYCQwAAAQYAn1EeAAu2BBYHAQF0VgArNAD//wBW//AESwYeBiYCAAAAAQYAnm8eAAu2ATAQAQFmVgArNAD//wBW//AESwYFBiYCAAAAAQcAoQCdAB4AC7YBMBABAU1WACs0AP//AFb/8ARLBfsGJgIAAAABBwCiAVMAJgALtgE0EAEBcFYAKzQA//8AVv37BEsEnQYmAgAAAAEHAdUBc/6XAA60ATQFAQG4/5mwVgArNP//AHYAAARnBh4GJgH/AAABBgCefR4AC7YDEQcBAXZWACs0AP///5EAAAJtBhIGJgH+AAABBwCl/xoAHwALtgEJAwEBf1YAKzQA////rwAAAlYFywYmAf4AAAEHAHD/EgAhAAu2AQYDAQGwVgArNAD///+6AAACRAYFBiYB/gAAAQcAof9FAB4AC7YBCQMBAV1WACs0AP//ABf+VAGNBI0GJgH+AAAABgCk7gD//wB9AAABggX7BiYB/gAAAQYAovwmAAu2AQ0DAQGAVgArNAD//wAm//AEPgYeBiYB/QAAAQcAngD6AB4AC7YBGQEBAXZWACs0AP//AHb+AwRnBI0GJgH8AAAABwHVART+n///AHYAAAOSBh4GJgH7AAABBgB1DR4AC7YCCAcBAWtWACs0AP//AHb+BAOSBI0GJgH7AAABBwHVARL+oAAOtAIRBgEBuP+VsFYAKzT//wB2AAADkgSQBiYB+wAAAAcB1QGSA5D//wB2AAADkgSNBiYB+wAAAAcAogF1/UH//wB2AAAEZwYeBiYB+QAAAQcAdQGIAB4AC7YBCgYBAWtWACs0AP//AHb9/QRnBI0GJgH5AAAABwHVAXz+mf//AHYAAARnBh4GJgH5AAABBwCfAJ8AHgALtgEQBgEBdFYAKzQA//8ATv/wBG4FywYmAfgAAAEGAHBwIQALtgIuEQEBoFYAKzQA//8ATv/wBG4GBQYmAfgAAAEHAKEAowAeAAu2AjERAQFNVgArNAD//wBO//AEbgYdBiYB+AAAAQcApgD7AB4ADbcDAjARAQFRVgArNDQA//8AdQAABDsGHgYmAfUAAAEHAHUBGgAeAAu2Ah8AAQFrVgArNAD//wB1/gQEOwSNBiYB9QAAAAcB1QEb/qD//wB1AAAEOwYeBiYB9QAAAQYAnzAeAAu2AiUAAQF0VgArNAD//wA///AD8AYeBiYB9AAAAQcAdQFHAB4AC7YBOg8BAVtWACs0AP//AD//8APwBh4GJgH0AAABBgCeRx4AC7YBPw8BAWZWACs0AP//AD/+PwPwBJ0GJgH0AAAABwB5AVIAAP//AD//8APwBh4GJgH0AAABBgCfXR4AC7YBQA8BAWZWACs0AP//ACX+AwQZBI0GJgHzAAABBwHVASn+nwAOtAIRAgEBuP+QsFYAKzT//wAlAAAEGQYeBiYB8wAAAQYAn0oeAAu2Ag4HAQF0VgArNAD//wAl/kYEGQSNBiYB8wAAAAcAeQE8AAf//wBp//AEIAYSBiYB8gAAAQYApV0fAAu2ARsLAQF/VgArNAD//wBp//AEIAXLBiYB8gAAAQYAcFUhAAu2ARgLAQGwVgArNAD//wBp//AEIAYFBiYB8gAAAQcAoQCIAB4AC7YBGwsBAV1WACs0AP//AGn/8AQgBngGJgHyAAABBwCjAPAAUwANtwIBIQsBAVFWACs0NAD//wBp//AEOAYdBiYB8gAAAQcApgDgAB4ADbcCARoLAQFhVgArNDQAAAIAaf6EBCAEjQAVACsAGkAMHiUXFhYRBgtyDAB9AD8yKzIyETMvMzAxQTMRFAYGIyImJjURMxEUFhYzMjY2NQMXDgIVFBYzMjY3FwYGIyImNTQ2NgMu8nzWiYvXevA5aklJaDhTcy9JKiAnHywOFxlOPFh6LmgEjf0AhrleXrmGAwD9AE1jLi5jTf7dOh49RSgeJxEHiw8dZmI0ZV3//wAnAAAF5QYeBiYB8AAAAQcAngEaAB4AC7YEGwoBAXZWACs0AP//AAYAAAQ4Bh4GJgHuAAABBgCeMR4AC7YDEwkBAXZWACs0AP//AAYAAAQ4BesGJgHuAAABBgBqUh4ADbcEAxcJAQGEVgArNDQA//8AQQAAA/UGHgYmAe0AAAEHAHUBNAAeAAu2Aw4NAQFrVgArNAD//wBBAAAD9QX7BiYB7QAAAQcAogEZACYAC7YDFw0BAYBWACs0AP//AEEAAAP1Bh4GJgHtAAABBgCfSx4AC7YDFA0BAXRWACs0AP//ABEAAAU/Bj8GJgAlAAABBgCurf8ADrQDDgMAALj/PrBWACs0////QgAABLEGQQQmAClkAAEHAK7+dQABAA60BBAHAAC4/z+wVgArNP///0sAAAV7BkAEJgAsZAAABwCu/n4AAP///04AAAIEBkIEJgAtZAABBwCu/oEAAgAOtAEEAwAAuP9BsFYAKzT///+1/+wFMQY/BCYAMxQAAQcArv7o//8ADrQCLBEAALj/KrBWACs0////QQAABT0GPwQmAD1kAAEHAK7+dP//AAu2AQoIAACOVgArNAD////CAAAE7wY/BCYAuhQAAQcArv71//8ADrQDNh0AALj/KrBWACs0////hf/0As4GmwYmAMMAAAEHAK//F//rABBACQMCASsAAQGiVgArNDQ0//8AEQAABT8FsAYGACUAAP//AJQAAASlBbAGBgAmAAD//wCUAAAETQWwBgYAKQAA//8AUAAABI4FsAYGAD4AAP//AJQAAAUXBbAGBgAsAAD//wClAAABoAWwBgYALQAA//8AlAAABRYFsAYGAC8AAP//AJQAAAZqBbAGBgAxAAD//wCUAAAFFwWwBgYAMgAA//8AZf/sBR0FxAYGADMAAP//AJQAAATPBbAGBgA0AAD//wAtAAAEtAWwBgYAOAAA//8ACAAABNkFsAYGAD0AAP//ACYAAATpBbAGBgA8AAD///++AAAChwcLBiYALQAAAQcAav9bAT4ADbcCARkDAQGDVgArNDQA//8ACAAABNkHAwYmAD0AAAEHAGoArQE2AA23AgEeAgEBd1YAKzQ0AP//AFb/6wR7BjwGJgC7AAABBwCuAUn//AALtgNCBgEBmlYAKzQA//8AYv/sBBIGOwYmAL8AAAEHAK4BFf/7AAu2AkArAQGaVgArNAD//wB9/mEEBgY8BiYAwQAAAQcArgEd//wAC7YCHQMBAa5WACs0AP//AKP/9AJeBiYGJgDDAAABBgCuAeYAC7YBEgABAZlWACs0AP//AH//6wQEBqMGJgDLAAABBgCvHPMAEEAJAwIBOA8BAaJWACs0NDT//wCNAAAEbQQ6BgYAjgAA//8ATv/sBDwETgYGAFMAAP//AJP+YAQkBDoGBgB2AAD//wAWAAAD3wQ6BgYAWgAA//8ANP5NBFsESgYGAosAAP///8P/9AKMBbgGJgDDAAABBwBq/2D/6wANtwIBJwABAaJWACs0NAD//wB//+sEBAXABiYAywAAAQYAamXzAA23AgE0DwEBolYAKzQ0AP//AE7/7AQ8BjwGJgBTAAABBwCuARv//AALtgIsBgEBmlYAKzQA//8Af//rBAQGLgYmAMsAAAEHAK4BBv/uAAu2AR8PAQGZVgArNAD//wBl/+sGMAYsBiYAzgAAAQcArgIn/+wAC7YCQB8BAZZWACs0AP//AJQAAARNBwsGJgApAAABBwBqAK4BPgANtwUEJQcBAYNWACs0NAD//wCZAAAENwc+BiYAsQAAAQcAdQGEAT4AC7YBBgUBAWxWACs0AAABAEv/7ASOBcQAOQAbQA0KJg82MSsJchgUDwNyACvMMyvMMxI5OTAxQTQuAicuAzU0PgIzMhYWFSM0JiYjIgYGFRQeAhceAxUUDgIjIi4CNTMUHgIzMjY2A5IbRHtfaK+CSEuLvnOi63/5PXteWXY6Jk52UHm0eDxKib91acumYvsxWHVDWHc8AXctRjo3HSBPaYlaWZJrO3jKekhvQDZcOilDOTIXJFdui1hck2c3OHOtdEdkPx4yWv//AKUAAAGgBbAGBgAtAAD///++AAAChwcLBiYALQAAAQcAav9bAT4ADbcCARkDAQGDVgArNDQA//8AL//sA+UFsAYGAC4AAP//AJkAAAUsBbAGBgJHAAD//wCUAAAFFgczBiYALwAAAQcAdQFxATMAC7YDDgMBAVtWACs0AP//ADL/6wThByUGJgDeAAABBwChANkBPgALtgIeAQEBXlYAKzQA//8AEQAABT8FsAYGACUAAP//AJQAAASlBbAGBgAmAAD//wCZAAAENwWwBgYAsQAA//8AlAAABE0FsAYGACkAAP//AJIAAAUNByUGJgDcAAABBwChARkBPgALtgEPAQEBXlYAKzQA//8AlAAABmoFsAYGADEAAP//AJQAAAUXBbAGBgAsAAD//wBl/+wFHQXEBgYAMwAA//8AmQAABRQFsAYGALYAAP//AJQAAATPBbAGBgA0AAD//wBm/+wE6wXEBgYAJwAA//8ALQAABLQFsAYGADgAAP//ACYAAATpBbAGBgA8AAD//wBW/+wD+QROBgYARQAA//8AUf/sBAoETgYGAEkAAP//AIQAAAQPBdoGJgDwAAABBwChAJL/8wALtgEPAQEBfVYAKzQA//8ATv/sBDwETgYGAFMAAP//AH3+YAQvBE4GBgBUAAAAAQBO/+wD8QROACcAE0AJAAkdFAdyCQtyACsrMhEzMDFlMjY2NzMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4CAjY7XzsD4wJ4xnh8uHo9PXq4e4LEcQLjAzVfQklgNhcWN2CsL1Q3aaxlVZbEcCNwxZZVZ7d5PGE6O2V9QyNDfmM7AP//AAz+SwPeBDoGBgBdAAD//wAfAAAD6gQ6BgYAXAAA//8AUf/sBAoFzQYmAEkAAAEGAGpjAAANtwIBQQsBAaNWACs0NAD//wCDAAADTAXzBiYA7AAAAQcAdQDE//MAC7YBBgUBAYtWACs0AP//AEn/7APHBE4GBgBXAAD//wB8AAABkAXWBgYATQAA////qAAAAnEFxAYmAI0AAAEHAGr/Rf/3AA23AgEZAwEBtVYAKzQ0AP///6v+SwGHBdYGBgBOAAD//wCPAAAEZQXyBiYA8QAAAQcAdQFL//IAC7YDDgMBAYpWACs0AP//AAz+SwPeBecGJgBdAAABBgChSQAAC7YCHgEBAZJWACs0AP//AC8AAAbmBzcGJgA7AAABBwBEAgIBNwALtgQYFQEBYVYAKzQA//8AIwAABcgGAAYmAFsAAAEHAEQBZQAAAAu2BBgVAQGgVgArNAD//wAvAAAG5gc3BiYAOwAAAQcAdQKpATcAC7YEFgEBAWFWACs0AP//ACMAAAXIBgAGJgBbAAABBwB1AgwAAAALtgQWAQEBoFYAKzQA//8ALwAABuYHBAYmADsAAAEHAGoBygE3AA23BQQrFQEBeFYAKzQ0AP//ACMAAAXIBc0GJgBbAAABBwBqAS0AAAANtwUEKxUBAbdWACs0NAD//wAIAAAE2Qc2BiYAPQAAAQcARADlATYAC7YBCwIBAWBWACs0AP//AAz+SwPeBgAGJgBdAAABBgBEdQAAC7YCGwEBAaBWACs0AP//AFID/gEJBgAGBgALAAD//wBgA/gCOgYABgYABgAA//8AjP/yA74FsAQmAAUAAAAHAAUCHgAA////qv5LAnEF3gYmAJwAAAEHAJ//PP/eAAu2ARgAAQGAVgArNAD//wA3BAUBYQYABgYBhgAA//8AlAAABmoHNwYmADEAAAEHAHUCkwE3AAu2AxEAAQFhVgArNAD//wB8AAAGfAYABiYAUQAAAQcAdQKkAAAAC7YDMwMBAaBWACs0AP//ABH+cgU/BbAGJgAlAAABBwCnAXQABAAQtQQDEQUBAbj/tbBWACs0NP//AFb+dwP5BE4GJgBFAAABBwCnAKcACQAQtQMCPjEBAbj/ybBWACs0NP//AJQAAARNBz4GJgApAAABBwBEAOUBPgALtgQSBwEBbFYAKzQA//8AkgAABQ0HPgYmANwAAAEHAEQBRAE+AAu2AQwBAQFsVgArNAD//wBR/+wECgYABiYASQAAAQcARACbAAAAC7YBLgsBAYxWACs0AP//AIQAAAQPBfMGJgDwAAABBwBEAL3/8wALtgEMAQEBi1YAKzQA//8ARgAABWQFsAYGALkAAP//AFL+JQV/BDoGBgDNAAD//wAQAAAE9Qb9BiYBGQAAAQcArAROAQ8ADbcDAhUTAQEtVgArNDQA////8gAABBoF0AYmARoAAAEHAKwD6v/iAA23AwIZFwEBe1YAKzQ0AP//AE7+SwhoBE4EJgBTAAAABwBdBIoAAP//AGX+SwlhBcQEJgAzAAAABwBdBYMAAP//AEn+NwSCBcQGJgDbAAABBwJsAZD/nQALtgJCKgAAZFYAKzQA//8ATv44A8cETQYmAO8AAAEHAmwBNP+eAAu2Aj8pAABlVgArNAD//wBm/joE6wXEBiYAJwAAAQcCbAHR/6AAC7YBKwUAAGRWACs0AP//AE7+OgPxBE4GJgBHAAABBwJsAUj/oAALtgErCQAAZFYAKzQA//8ACAAABNkFsAYGAD0AAP//AB7+XwP1BDoGBgC9AAD//wClAAABoAWwBgYALQAA//8AFQAAB6IHJQYmANoAAAEHAKECHgE+AAu2BR0NAQFeVgArNAD//wAgAAAGawXaBiYA7gAAAQcAoQGO//MAC7YFHQ0BAX1WACs0AP//AKUAAAGgBbAGBgAtAAD//wARAAAFPwceBiYAJQAAAQcAoQDwATcAC7YDEwcBAVNWACs0AP//AFb/7AP5BecGJgBFAAABBgChewAAC7YCQA8BAX5WACs0AP//ABEAAAU/BwQGJgAlAAABBwBqAOQBNwANtwQDIwcBAXhWACs0NAD//wBW/+wD+QXNBiYARQAAAQYAam8AAA23AwJQDwEBo1YAKzQ0AP////wAAAdOBbAGBgCBAAD//wBI/+sGhgRPBgYAhgAA//8AlAAABE0HJQYmACkAAAEHAKEAugE+AAu2BBUHAQFeVgArNAD//wBR/+wECgXnBiYASQAAAQYAoXAAAAu2ATELAQF+VgArNAD//wBV/+sFIwbcBiYBWAAAAQcAagDCAQ8ADbcCAUIAAQFBVgArNDQA//8AV//sA/YEUAYGAJ0AAP//AFf/7AP2Bc4GJgCdAAABBgBqYgEADbcCAUAAAQGiVgArNDQA//8AFQAAB6IHCwYmANoAAAEHAGoCEQE+AA23BgUtDQEBg1YAKzQ0AP//ACAAAAZrBcAGJgDuAAABBwBqAYH/8wANtwYFLQ0BAaJWACs0NAD//wBJ/+wEggcYBiYA2wAAAQcAagCfAUsADbcDAlQVAQGEVgArNDQA//8ATv/sA8cFzAYmAO8AAAEGAGpI/wANtwMCURQBAaNWACs0NAD//wCSAAAFDQbqBiYA3AAAAQcAcADmAUAAC7YBDAgBAbFWACs0AP//AIQAAAQPBaAGJgDwAAABBgBwXvYAC7YBDAgBAdBWACs0AP//AJIAAAUNBwsGJgDcAAABBwBqAQwBPgANtwIBHwEBAYNWACs0NAD//wCEAAAEDwXABiYA8AAAAQcAagCF//MADbcCAR8BAQGiVgArNDQA//8AZf/sBR0HBQYmADMAAAEHAGoA/AE4AA23AwJBEQEBZlYAKzQ0AP//AE7/7AQ8Bc0GJgBTAAABBgBqeQAADbcDAkEGAQGjVgArNDQA//8AYP/sBRkFxAYGARcAAP//AE3/7AQ7BE4GBgEYAAD//wBg/+wFGQcHBiYBFwAAAQcAagEMAToADbcEA08AAQFqVgArNDQA//8ATf/sBDsFzgYmARgAAAEGAGptAQANtwQDQQABAaVWACs0NAD//wBj/+wE6AcZBiYA5wAAAQcAagDZAUwADbcDAkIeAQGFVgArNDQA//8AUP/rA+gFzQYmAP8AAAEGAGpQAAANtwMCQQkBAaNWACs0NAD//wAy/+sE4QbqBiYA3gAAAQcAcACmAUAAC7YCGxgBAbFWACs0AP//AAz+SwPeBa0GJgBdAAABBgBwFgMAC7YCGxgBAeVWACs0AP//ADL/6wThBwsGJgDeAAABBwBqAM0BPgANtwMCLgEBAYNWACs0NAD//wAM/ksD3gXNBiYAXQAAAQYAaj0AAA23AwIuAQEBt1YAKzQ0AP//ADL/6wThBz0GJgDeAAABBwCmATEBPgANtwMCGQEBAWJWACs0NAD//wAM/ksD+QX/BiYAXQAAAQcApgChAAAADbcDAhkBAQGWVgArNDQA//8AkQAABO0HCwYmAOEAAAEHAGoBDgE+AA23AwIvFgEBg1YAKzQ0AP//AGAAAAPhBcAGJgD5AAABBgBqYvMADbcDAi0DAQGiVgArNDQA//8AmQAABlQHCwYmAOUAAAEHAGoBugE+AA23AwIyHAEBg1YAKzQ0AP//AI8AAAXPBcAGJgD9AAABBwBqAXT/8wANtwMCMhwBAaJWACs0NAD//wBQ/+wEAgYABgYASAAA//8AEf6aBT8FsAYmACUAAAEHAK0FCgADAA60AxEFAQG4/3WwVgArNP//AFb+nwP5BE4GJgBFAAABBwCtBD0ACAAOtAI+MQEBuP+JsFYAKzT//wARAAAFPwe6BiYAJQAAAQcAqwUDAT0AC7YDDwcBAXFWACs0AP//AFb/7AP5BoQGJgBFAAABBwCrBI0ABwALtgI8DwEBnFYAKzQA//8AEQAABT8HqwYmACUAAAEHAlIAwgEhAA23BAMSBwEBYVYAKzQ0AP//AFb/7ATIBnQGJgBFAAABBgJSTeoADbcDAkEPAQGMVgArNDQA//8AEQAABT8HqQYmACUAAAEHAlMAwwEqAA23BAMQBwEBXFYAKzQ0AP///5//7AP5BnIGJgBFAAABBgJTTvMADbcDAj0PAQGHVgArNDQA//8AEQAABT8H3QYmACUAAAEHAlQAwgEVAA23BAMTAwEBUFYAKzQ0AP//AFb/7ARTBqYGJgBFAAABBgJUTd4ADbcDAkAPAQF7VgArNDQA//8AEQAABT8H1AYmACUAAAEHAlUAxAEHAA23BAMQBwEBOlYAKzQ0AP//AFb/7AP5Bp0GJgBFAAABBgJVT9AADbcDAj0PAQFlVgArNDQA//8AEf6aBT8HNwYmACUAAAAnAJ4AwgE3AQcArQUKAAMAF7QEGgUBAbj/dbdWAxEHAQFsVgArNCs0AP//AFb+nwP5BgAGJgBFAAAAJgCeTQABBwCtBD0ACAAXtANHMQEBuP+Jt1YCPg8BAZdWACs0KzQA//8AEQAABT8HrgYmACUAAAEHAlcA6gEyAA23BAMTBwEBXFYAKzQ0AP//AFb/7AP5BngGJgBFAAABBgJXdfwADbcDAkAPAQGHVgArNDQA//8AEQAABT8HrgYmACUAAAEHAlAA6gEyAA23BAMTBwEBXFYAKzQ0AP//AFb/7AP5BngGJgBFAAABBgJQdfwADbcDAkAPAQGHVgArNDQA//8AEQAABT8IPQYmACUAAAEHAlgA6AE2AA23BAMTBwEBblYAKzQ0AP//AFb/7AP5BwYGJgBFAAABBgJYc/8ADbcDAkAPAQGZVgArNDQA//8AEQAABT8IFgYmACUAAAEHAmsA6wE8AA23BAMTBwEBb1YAKzQ0AP//AFb/7AP5Bt8GJgBFAAABBgJrdgUADbcDAkAPAQGaVgArNDQA//8AEf6aBT8HHgYmACUAAAAnAKEA8AE3AQcArQUKAAMAF7QEIAUBAbj/dbdWAxMHAQFTVgArNCs0AP//AFb+nwP5BecGJgBFAAAAJgChewABBwCtBD0ACAAXtANNMQEBuP+Jt1YCQA8BAX5WACs0KzQA//8AlP6hBE0FsAYmACkAAAEHAK0EywAKAA60BBMCAQG4/3+wVgArNP//AFH+lwQKBE4GJgBJAAABBwCtBI4AAAAOtAEvAAEBuP+JsFYAKzT//wCUAAAETQfBBiYAKQAAAQcAqwTNAUQAC7YEEQcBAXxWACs0AP//AFH/7AQKBoQGJgBJAAABBwCrBIIABwALtgEtCwEBnFYAKzQA//8AlAAABE0HMQYmACkAAAEHAKUAjwE+AAu2BB4HAQF2VgArNAD//wBR/+wECgX0BiYASQAAAQYApUUBAAu2AToLAQGWVgArNAD//wCUAAAFBweyBiYAKQAAAQcCUgCMASgADbcFBBQHAQFsVgArNDQA//8AUf/sBL0GdQYmAEkAAAEGAlJC6wANtwIBMAsBAYxWACs0NAD////eAAAETQewBiYAKQAAAQcCUwCNATEADbcFBBIHAQFnVgArNDQA////lP/sBAoGcwYmAEkAAAEGAlND9AANtwIBLgsBAYdWACs0NAD//wCUAAAEkgfkBiYAKQAAAQcCVACMARwADbcFBBUHAQFbVgArNDQA//8AUf/sBEgGpwYmAEkAAAEGAlRC3wANtwIBMQsBAXtWACs0NAD//wCUAAAETQfbBiYAKQAAAQcCVQCOAQ4ADbcFBBIHAQFFVgArNDQA//8AUf/sBAoGngYmAEkAAAEGAlVD0QANtwIBLgsBAWVWACs0NAD//wCU/qEETQc+BiYAKQAAACcAngCNAT4BBwCtBMsACgAXtAUcAgEBuP9/t1YEEwcBAXdWACs0KzQA//8AUf6XBAoGAAYmAEkAAAAmAJ5CAAEHAK0EjgAAABe0AjgAAQG4/4m3VgEvCwEBl1YAKzQrNAD//wClAAACFQfBBiYALQAAAQcAqwN6AUQAC7YBBQMBAXxWACs0AP//AJAAAAH/BnsGJgCNAAABBwCrA2T//gALtgEFAwEBrlYAKzQA//8Alv6dAakFsAYmAC0AAAEHAK0DeAAGAA60AQcCAQG4/36wVgArNP//AHj+oQGQBdYGJgBNAAABBwCtA1oACgAOtAITAgEBuP9/sFYAKzT//wBl/pcFHQXEBiYAMwAAAQcArQUbAAAADrQCLwYBAbj/ibBWACs0//8ATv6TBDwETgYmAFMAAAEHAK0Emv/8AA60Ai8RAQG4/4iwVgArNP//AGX/7AUdB7wGJgAzAAABBwCrBRsBPwALtgItEQEBX1YAKzQA//8ATv/sBDwGhAYmAFMAAAEHAKsEmAAHAAu2Ai0GAQGcVgArNAD//wBl/+wFVQesBiYAMwAAAQcCUgDaASIADbcDAjARAQFPVgArNDQA//8ATv/sBNIGdAYmAFMAAAEGAlJX6gANtwMCMAYBAYxWACs0NAD//wAs/+wFHQeqBiYAMwAAAQcCUwDbASsADbcDAi4RAQFKVgArNDQA////qv/sBDwGcgYmAFMAAAEGAlNZ8wANtwMCLgYBAYdWACs0NAD//wBl/+wFHQfeBiYAMwAAAQcCVADaARYADbcDAjERAQE+VgArNDQA//8ATv/sBF4GpgYmAFMAAAEGAlRY3gANtwMCMQYBAXtWACs0NAD//wBl/+wFHQfVBiYAMwAAAQcCVQDcAQgADbcDAi4RAQEoVgArNDQA//8ATv/sBDwGnQYmAFMAAAEGAlVZ0AANtwMCLgYBAWVWACs0NAD//wBl/pcFHQc4BiYAMwAAACcAngDaATgBBwCtBRsAAAAXtAM4BgEBuP+Jt1YCLxEBAVpWACs0KzQA//8ATv6TBDwGAAYmAFMAAAAmAJ5YAAEHAK0Emv/8ABe0AzgRAQG4/4i3VgIvBgEBl1YAKzQrNAD//wBb/+wFrwc1BiYAmAAAAQcAdQHZATUAC7YDOhwBAUdWACs0AP//AE3/7AS3BgAGJgCZAAABBwB1AVsAAAALtgM2EAEBjFYAKzQA//8AW//sBa8HNQYmAJgAAAEHAEQBMgE1AAu2AzwcAQFHVgArNAD//wBN/+wEtwYABiYAmQAAAQcARAC1AAAAC7YDOBABAYxWACs0AP//AFv/7AWvB7kGJgCYAAABBwCrBRoBPAALtgM7HAEBV1YAKzQA//8ATf/sBLcGhAYmAJkAAAEHAKsEnAAHAAu2AzcQAQGcVgArNAD//wBb/+wFrwcpBiYAmAAAAQcApQDcATYAC7YDSBwBAVFWACs0AP//AE3/7AS3BfQGJgCZAAABBgClXwEAC7YDRBABAZZWACs0AP//AFv+lwWvBisGJgCYAAABBwCtBQUAAAAOtAM9EAEBuP+JsFYAKzT//wBN/o0EtwSoBiYAmQAAAQcArQSZ//YADrQDORsBAbj/f7BWACs0//8AgP6XBL8FsAYmADkAAAEHAK0E8wAAAA60ARkGAQG4/4mwVgArNP//AHf+lwP5BDoGJgBZAAABBwCtBD4AAAAOtAIfCwEBuP+JsFYAKzT//wCA/+wEvwe6BiYAOQAAAQcAqwT2AT0AC7YBFwABAXFWACs0AP//AHf/7AP5BoQGJgBZAAABBwCrBJMABwALtgIdEQEBsFYAKzQA//8AgP/sBjoHQgYmAJoAAAEHAHUB2gFCAAu2AiAKAQFsVgArNAD//wB3/+wFJAXrBiYAmwAAAQcAdQFa/+sAC7YDJhsBAYtWACs0AP//AID/7AY6B0IGJgCaAAABBwBEATMBQgALtgIiCgEBbFYAKzQA//8Ad//sBSQF6wYmAJsAAAEHAEQAs//rAAu2AygbAQGLVgArNAD//wCA/+wGOgfGBiYAmgAAAQcAqwUaAUkAC7YCIQoBAXxWACs0AP//AHf/7AUkBm8GJgCbAAABBwCrBJr/8gALtgMnGwEBm1YAKzQA//8AgP/sBjoHNgYmAJoAAAEHAKUA3QFDAAu2Ai4VAQF2VgArNAD//wB3/+wFJAXfBiYAmwAAAQYApV3sAAu2AzQbAQGVVgArNAD//wCA/o4GOgYCBiYAmgAAAQcArQUW//cADrQCIxABAbj/gLBWACs0//8Ad/6XBSQElQYmAJsAAAEHAK0EjgAAAA60AykVAQG4/4mwVgArNP//AAj+qQTZBbAGJgA9AAABBwCtBMYAEgAOtAEMBgEBuP92sFYAKzT//wAM/hED3gQ6BiYAXQAAAQcArQVN/3oADrQCIggAALj/ubBWACs0//8ACAAABNkHugYmAD0AAAEHAKsEzAE9AAu2AQoCAQFwVgArNAD//wAM/ksD3gaEBiYAXQAAAQcAqwRcAAcAC7YCGgEBAbBWACs0AP//AAgAAATZByoGJgA9AAABBwClAI8BNwALtgEXCAEBalYAKzQA//8ADP5LA94F9AYmAF0AAAEGAKUfAQALtgInGAEBqlYAKzQA//8AUP6wBK0GAAQmAEgAAAAnAkEBgAI/AQcAQwCZ/2wAF7QENxYBAbj/d7dWAzILAQGDVgArNCs0AP//AC3+mgS0BbAGJgA4AAABBwJsAkYAAAALtgILAgAAmlYAKzQA//8AI/6aA9UEOgYmAPYAAAEHAmwB3wAAAAu2AgsCAACaVgArNAD//wCR/poE7QWwBiYA4QAAAQcCbALOAAAAC7YCHRkBAJpWACs0AP//AGD+mgPhBDsGJgD5AAABBwJsAccAAAALtgIbAgEAmlYAKzQA//8Amf6aBDcFsAYmALEAAAEHAmwA/AAAAAu2AQkEAACaVgArNAD//wCD/poDTAQ6BiYA7AAAAQcCbADhAAAAC7YBCQQAAJpWACs0AP//AAr+PQW0BcQGJgFMAAABBwJsAt//owALtgI6CgAAa1YAKzQA////y/5EBJAETgYmAU0AAAEHAmwB7/+qAAu2AjkJAABrVgArNAD//wB6AAAD+gYABgYATAAAAAL/1wAABLoFsAAYABwAGkAMHBsYAAALDAJyDgsIAD8zKxI5LzPMMjAxQSEyFhYVFA4CIyERMxEhMjY2NTQmJiMhARUhNQE+AW6m7HxGiMN9/eT8ASBfejs7el/+kgE4/WEDgW/IhWSmeUIFsPsXR3RFQ25CAjWnpwAAAv/XAAAEugWwABgAHAAZQAscGxgAAAsMAg4LCAA/Mz8SOS8zzDIwMUEhMhYWFRQOAiMhETMRITI2NjU0JiYjIQEVITUBPgFupux8RojDff3k/AEgX3o7O3pf/pIBOP1hA4FvyIVkpnlCBbD7F0d0RUNuQgI1p6cAAv/0AAAENwWwAAUACQAWQAoGBwcEAgUCcgQIAD8rMhI5LzMwMUEVIREjEQEVITUEN/1c+gH6/WEFsMj7GAWw/ZempgAC/98AAANMBDoABQAJABZACgkICAQCBQZyBAoAPysyEjkvMzAxQRUhESMRARUhNQNM/ijxAfv9YQQ6wPyGBDr+P6enAAT/8wAABUAFsAADAAkADQARACtAFQwLCwcHBhARBhEGEQIJAwJyCgIIcgArMisyETk5Ly8RMxEzEjkRMzAxQREjESEBISczARMBNwEBFSE1Aaf6BGb9sP6dIvoBqDP+KaICYv1S/WEFsPpQBbD8wtoCZPpQApjB/KcE56enAAT/yQAABEcGAAADAAkADQARAC1AFwQGcgwLCwcHBhARBhEGEQIDAHIKAgpyACsyKxE5OS8vETMRMxI5ETMrMDFBESMRAQEhJzMBEwE3AQEVITUBhfADh/5G/txF8QEYLf6unQHN/iH9YQYA+gAGAP46/aG/AaD7xgH6qv1cBWOmpgACAAgAAATZBbAACAAMAB1ADwwBBAcDCwsGAwgCcgYIcgArKzIROS8XOTMwMUEBASEBESMRAQEVITUBHwFSAVIBFv4W/f4WA7/9YAWw/UkCt/xo/egCGAOY/PynpwAABAAe/l8D9QQ6AAMACAANABEAF0ALERAQAgUNBnICDnIAKysyEjkvMzAxZREjETcTMwEjAwEXIwEBFSE1AoHxb/v7/oGivAEEJKL+gANB/WFt/fICDpUDOPvGBDr8xP4EOvxspqYAAgAmAAAE6QWwAAsADwAfQA8PBwUBBAoDDg4JBQMAAnIAKzIvMzkvFzkSOTMwMUEBASEBASEBASEJAhUhNQFTATUBNQEh/kgBw/7c/sP+w/7bAcT+RwOq/WAFsP3tAhP9L/0hAh394wLfAtH9jaenAAIAHwAAA+oEOgALAA8AH0APDwcFAQoEAw4OCQUDAAZyACsyLzM5Lxc5EjkzMDFBExMhAQEhAwMhCQIVITUBNM7SAQn+uAFV/vfc3P72AVT+uQMt/WEEOv6ZAWf97f3ZAXb+igInAhP+Raam//8AYv/sBBIETQYGAL8AAP//AAEAAAQ0BbAGJgAqAAABBwJB/3T+ZQAOtAMOAgIAuAEIsFYAKzT//wB7AnAFzAMxBgYBgwAA//8AUgAABD4FxAYGABYAAP//AE7/7AQaBcQGBgAXAAD//wA3AAAEWQWwBgYAGAAA//8Af//sBDkFsAYGABkAAP//AIf/7ARNBbkEBgAaFAD//wB7/+wEOgXEBAYAHBQA//8AXf/3BBUFxAQGAB0AAP//AHz/7AQ3BcQEBgAUFAD//wBr/+wE8gdLBiYAKwAAAQcAdQHGAUsAC7YBLBABAW1WACs0AP//AFL+VQQMBgAGJgBLAAABBwB1AUMAAAALtgM/GgEBjFYAKzQA//8AlAAABRcHNwYmADIAAAEHAEQBRwE3AAu2AQwJAQFhVgArNAD//wB6AAAD+gYABiYAUgAAAQcARACwAAAAC7YCHgMBAaBWACs0AP//ABEAAAU/ByEGJgAlAAABBwCsBHsBMwANtwQDDgMBAWZWACs0NAD//wAO/+wD+QXrBiYARQAAAQcArAQG//0ADbcDAjwPAQGRVgArNDQA//8ATgAABE0HKAYmACkAAAEHAKwERgE6AA23BQQRBwEBcVYAKzQ0AP//AAP/7AQKBesGJgBJAAABBwCsA/v//QANtwIBLQsBAZFWACs0NAD///77AAACIwcoBiYALQAAAQcArALzAToADbcCAQUDAQFxVgArNDQA///+5AAAAgwF4gYmAI0AAAEHAKwC3P/0AA23AgEFAwEBo1YAKzQ0AP//AGX/7AUdByMGJgAzAAABBwCsBJMBNQANtwMCLREBAVRWACs0NAD//wAZ/+wEPAXrBiYAUwAAAQcArAQR//0ADbcDAi0GAQGRVgArNDQA//8ANQAABN8HIQYmADYAAAEHAKwELQEzAA23AwIfAAEBZlYAKzQ0AP///3MAAAK5BesGJgBWAAABBwCsA2v//QANtwMCGAMBAaVWACs0NAD//wB3/+wEvwchBiYAOQAAAQcArARvATMADbcCARcLAQFmVgArNDQA//8AFP/sA/kF6wYmAFkAAAEHAKwEDP/9AA23AwIdEQEBpVYAKzQ0AP///wwAAAUPBj8EJgDQZAAABwCu/j//////AJT+oQSlBbAGJgAmAAABBwCtBLMACgAOtAI0GwEBuP9/sFYAKzT//wB9/o0EMAYABiYARgAAAQcArQTO//YADrQDMwQBAbj/a7BWACs0//8AlP6hBNIFsAYmACgAAAEHAK0EigAKAA60AiIdAQG4/3+wVgArNP//AFD+lwQCBgAGJgBIAAABBwCtBK8AAAAOtAMzFgEBuP+JsFYAKzT//wCU/gYE0gWwBiYAKAAAAQcB1QFC/qIADrQCKB0BAbj/l7BWACs0//8AUP38BAIGAAYmAEgAAAEHAdUBZv6YAA60AzkWAQG4/6GwVgArNP//AJT+oQUXBbAGJgAsAAABBwCtBSYACgAOtAMPCgEBuP9/sFYAKzT//wB6/qED+gYABiYATAAAAQcArQSfAAoADrQCHgIBAbj/f7BWACs0//8AlAAABRYHMwYmAC8AAAEHAHUBcQEzAAu2Aw4DAQFbVgArNAD//wB9AAAENwc9BiYATwAAAQcAdQF3AT0AC7YDDgMBABtWACs0AP//AJT+4wUWBbAGJgAvAAABBwCtBOUATAAOtAMRAgEBuP/PsFYAKzT//wB9/s8ENwYABiYATwAAAQcArQR6ADgADrQDEQIBAbj/vLBWACs0//8AlP6hBCQFsAYmADAAAAEHAK0EtwAKAA60AgsCAQG4/3+wVgArNP//AHj+oQGLBgAGJgBQAAABBwCtA1oACgAOtAEHAgEBuP9/sFYAKzT//wCU/qEGagWwBiYAMQAAAQcArQXUAAoADrQDFAYBAbj/f7BWACs0//8AfP6hBnwETgYmAFEAAAEHAK0F2gAKAA60AzYCAQG4/3+wVgArNP//AJT+nQUXBbAGJgAyAAABBwCtBSgABgAOtAENAgEBuP9/sFYAKzT//wB6/qED+gROBiYAUgAAAQcArQSPAAoADrQCHwIBAbj/f7BWACs0//8AZf/sBR0H3gYmADMAAAEHAlEFAAFVAA23AwIxEQEBWlYAKzQ0AP//AJQAAATPB0IGJgA0AAABBwB1AXIBQgALtgEYDwEBbFYAKzQA//8Aff5gBC8F9gYmAFQAAAEHAHUBoP/2AAu2AzADAQGWVgArNAD//wCU/qEE3wWwBiYANgAAAQcArQS5AAoADrQCIRgBAbj/f7BWACs0//8Acf6iArkETgYmAFYAAAEHAK0DUwALAA60AhoCAQG4/4CwVgArNP//AEv+lgSOBcQGJgA3AAABBwCtBNb//wAOtAE9KwEBuP+IsFYAKzT//wBJ/o0DxwROBiYAVwAAAQcArQR0//YADrQBOSkBAbj/f7BWACs0//8ALf6bBLQFsAYmADgAAAEHAK0ExAAEAA60AgsCAQG4/3WwVgArNP//AAr+lwJ1BUMGJgBYAAABBwCtBA8AAAAOtAIZEQEBuP+JsFYAKzT//wCA/+wEvwfcBiYAOQAAAQcCUQTbAVMADbcCARsAAQFsVgArNDQA//8AEQAABRsHNgYmADoAAAEHAKUAsgFDAAu2AhgJAQF2VgArNAD//wAWAAAD3wXqBiYAWgAAAQYApR33AAu2AhgJAQGgVgArNAD//wAR/qEFGwWwBiYAOgAAAQcArQTsAAoADrQCDQQBAbj/f7BWACs0//8AFv6hA98EOgYmAFoAAAEHAK0EVgAKAA60Ag0EAQG4/3+wVgArNP//AC/+oQbmBbAGJgA7AAABBwCtBeMACgAOtAQZEwEBuP9/sFYAKzT//wAj/qEFyAQ6BiYAWwAAAQcArQVMAAoADrQEGRMBAbj/f7BWACs0//8AUP6hBI4FsAYmAD4AAAEHAK0ExAAKAA60AxECAQG4/3+wVgArNP//AFH+oQPBBDoGJgBeAAABBwCtBGQACgAOtAMRAgEBuP9/sFYAKzT///5s/+wFYwXWBCYAM0YAAQcBcv4I//8ADbcDAi4RAAASVgArNDQA//8ACAAABJEFHAYmAk4AAAAHAK7/X/7c////YwAAA/IFHwQmAkM8AAAHAK7+lv7f////awAABKMFGgQmAf88AAAHAK7+nv7a////bgAAAbQFHwQmAf48AAAHAK7+of7f////mf/wBHgFHAQmAfgKAAAHAK7+zP7c////IAAABHQFHAQmAe48AAAHAK7+U/7c////qwAABIsFHAQmAg4KAAAHAK7+3v7c//8ACAAABJEEjQYGAk4AAP//AHYAAAQMBI0GBgJNAAD//wB2AAADtgSNBgYCQwAA//8AQQAAA/UEjQYGAe0AAP//AHYAAARnBI0GBgH/AAD//wCGAAABeASNBgYB/gAA//8AdgAABGcEjQYGAfwAAP//AHYAAAWPBI0GBgH6AAD//wB2AAAEZwSNBgYB+QAA//8ATv/wBG4EnQYGAfgAAP//AHYAAAQoBI0GBgH3AAD//wAlAAAEGQSNBgYB8wAA//8ABgAABDgEjQYGAe4AAP//ABMAAARJBI0GBgHvAAD///+cAAACZQXrBiYB/gAAAQcAav85AB4ADbcCAQ0DAQGEVgArNDQA//8ABgAABDgF6wYmAe4AAAEGAGpSHgANtwQDFwkBAYNWACs0NAD//wB2AAADtgXrBiYCQwAAAQYAalweAA23BQQZBwEBg1YAKzQ0AP//AHYAAAOZBh4GJgIFAAABBwB1ASMAHgALtgIIAwEBg1YAKzQA//8AP//wA/AEnQYGAfQAAP//AIYAAAF4BI0GBgH+AAD///+cAAACZQXrBiYB/gAAAQcAav85AB4ADbcCAQ0DAQGEVgArNDQA//8AJv/wA2UEjQYGAf0AAP//AHYAAARnBh4GJgH8AAABBwB1ARoAHgALtgMOAwEBhFYAKzQA//8AH//sBEEGBQYmAhwAAAEGAKF9HgALtgIdFwEBhFYAKzQA//8ACAAABJEEjQYGAk4AAP//AHYAAAQMBI0GBgJNAAD//wB2AAADmQSNBgYCBQAA//8AdgAAA7YEjQYGAkMAAP//AHYAAARtBgUGJgIZAAABBwChALYAHgALtgMRCAEBhFYAKzQA//8AdgAABY8EjQYGAfoAAP//AHYAAARnBI0GBgH/AAD//wBO//AEbgSdBgYB+AAA//8AdgAABGMEjQYGAgoAAP//AHYAAAQoBI0GBgH3AAD//wBP//AEQwSdBgYCTAAA//8AJQAABBkEjQYGAfMAAP//ABMAAARJBI0GBgHvAAAAAwBD/jcD6gSdAB4APgBCAChAEx8BAgI+PhU/NDRAMCoLcg8LFX4APzPMK8zNMxI5EjkvMxI5OTAxQSM1MzI2NjU0JiYjIgYGFSM0PgIzMh4CFRQOAiUzMh4CFRQOAiMiLgI1Mx4CMzI2NjU0LgIjIwERIxECObmRTV4qLWBPNVk38UN4n11pqXhCP3CX/u+5bKJtNkeCrmhRoYVR8QQ6YDtRaDIeO1g6jQEC8QIsfSdFLypFKh08Lk55VCwoT3dPQ3FTLUYtUm9BVH9VKyRQhF81QyAqSTAsQSoV/lL95wIZAAQAdv6aBSgEjQADAAcACwAPAB1ADQMCAgYLB30PDgoKBhIAPzMQzjM/MxI5LzMwMUEVITUTESMRIREjEQERIxEDt/1sRPED8fEBsvECncDAAfD7cwSN+3MEjfwm/ecCGQAAAgBP/kAEQwSdACcAKwAYQAsZEH4oJCQqKgULcgArMi8yETM/MzAxQTMOAiMiLgI1NTQ+AjMyFhYXIy4CIyIOAhUVFB4CMzI2NgcRIxEDUPIJediZd72FR0iIvXab1HYM8QY2bFhEZkUjH0JnR1VsOoTxAYR3tmdOkc+BToHPk01punhBYzgvXolaT1iJXjEvYOX95wIZAP//AAYAAAQ4BI0GBgHuAAD//wAO/jcFrASkBiYCMgAAAAcCbALm/53//wB2AAAEbQXLBiYCGQAAAQcAcACCACEAC7YDDggBAbBWACs0AP//AB//7ARBBcsGJgIcAAABBgBwSiEAC7YCGhcBAbBWACs0AP//AE8AAAVXBI0GBgIMAAD//wCG//AFYwSNBCYB/gAAAAcB/QH+AAD////sAAAGBAYABiYCjwAAAQcAdQKBAAAAC7YGGQ8BAU1WACs0AP//AE7/xwRuBh4GJgKRAAABBwB1AXUAHgALtgMwEQEBW1YAKzQA//8AP/38A/AEnQYmAfQAAAAHAdUBP/6Y//8AJwAABeUGHgYmAfAAAAEHAEQBcwAeAAu2BBgKAQFrVgArNAD//wAnAAAF5QYeBiYB8AAAAQcAdQIZAB4AC7YEFgoBAWtWACs0AP//ACcAAAXlBesGJgHwAAABBwBqATsAHgANtwUEHwoBAYRWACs0NAD//wAGAAAEOAYeBiYB7gAAAAcARACKAB7//wAR/lcFPwWwBiYAJQAAAQcApAGAAAMAC7YDDgUBATlWACs0AP//AFb+XAP5BE4GJgBFAAABBwCkALQACAALtgI7MQAATVYAKzQA//8AlP5eBE0FsAYmACkAAAEHAKQBQgAKAAu2BBACAABDVgArNAD//wBR/lQECgROBiYASQAAAQcApAEFAAAAC7YBLAAAAE1WACs0AP//AAj+VASRBI0GJgJOAAAABwCkASIAAP//AHb+XAO2BI0GJgJDAAAABwCkAPEACP//AHj+oQGLBDoGJgCNAAABBwCtA1oACgAOtAEHAgEBuP9/sFYAKzQAAQCyAIkEJAP7AA8ACLEIAAAvLzAxZSImJjU0NjYzMhYWFRQGBgJresh3d8h6esh3d8iJd8h6esh3d8h6esh3AAEAkwAABEEDrwADAAizAQAScgArL3MRIRGTA64Dr/xRAAAEAGT/7wWoBcIAEAAYACAAKgAXQAkgECQIGBAcCBAALy8zETMRMxEzMDF3NjY3JRE2NjcRFAYHBwYGBwU2NjclBgYHATY2NwEGBgcBETY2NxElBgYHZAIcGAGFKGs3CglPEjYgAU0FGhkCBAQdF/s+AR4YBMMEHhf9/yloOgFvBB0XeTpvMlMDfTVSF/wKDx4MeRojBug4cTNtOXIvAa07bjIBAzpxMv44A5I1URr8yE44czEAAAIAsgCJBCQD+wAPAB8AELcAEGoIGGoIAAAvLysrMDFlIiYmNTQ2NjMyFhYVFAYGJzI2NjU0JiYjIgYGFRQWFgJresh3d8h6esh3d8h6ZqViYqVmZaZiYqaJd8h6esh3d8h6esh3TGKmZWalYmKlZmWmYgAAAAAAABEA0gADAAEECQAAALIAAAADAAEECQABABoAsgADAAEECQACAA4AzAADAAEECQADABoAsgADAAEECQAEABoAsgADAAEECQAFACYA2gADAAEECQAGABoBAAADAAEECQAHAEABGgADAAEECQAIAAwBWgADAAEECQAJACYBZgADAAEECQALABQBjAADAAEECQAMABQBjAADAAEECQANASIBoAADAAEECQAOADYCwgADAAEECQAQAAwC+AADAAEECQARAAwDBAADAAEECQAZAAwC+ABDAG8AcAB5AHIAaQBnAGgAdAAgADIAMAAxADEAIABUAGgAZQAgAFIAbwBiAG8AdABvACAAUAByAG8AagBlAGMAdAAgAEEAdQB0AGgAbwByAHMAIAAoAGgAdAB0AHAAcwA6AC8ALwBnAGkAdABoAHUAYgAuAGMAbwBtAC8AZwBvAG8AZwBsAGUAZgBvAG4AdABzAC8AcgBvAGIAbwB0AG8ALQBjAGwAYQBzAHMAaQBjACkAUgBvAGIAbwB0AG8AIABNAGUAZABpAHUAbQBSAGUAZwB1AGwAYQByAFYAZQByAHMAaQBvAG4AIAAzAC4AMAAxADQAOwAgADIAMAAyADUAUgBvAGIAbwB0AG8ALQBNAGUAZABpAHUAbQBSAG8AYgBvAHQAbwAgAGkAcwAgAGEAIAB0AHIAYQBkAGUAbQBhAHIAawAgAG8AZgAgAEcAbwBvAGcAbABlAC4ARwBvAG8AZwBsAGUAQwBoAHIAaQBzAHQAaQBhAG4AIABSAG8AYgBlAHIAdABzAG8AbgBHAG8AbwBnAGwAZQAuAGMAbwBtAFQAaABpAHMAIABGAG8AbgB0ACAAUwBvAGYAdAB3AGEAcgBlACAAaQBzACAAbABpAGMAZQBuAHMAZQBkACAAdQBuAGQAZQByACAAdABoAGUAIABTAEkATAAgAE8AcABlAG4AIABGAG8AbgB0ACAATABpAGMAZQBuAHMAZQAsACAAVgBlAHIAcwBpAG8AbgAgADEALgAxAC4AIABUAGgAaQBzACAAbABpAGMAZQBuAHMAZQAgAGkAcwAgAGEAdgBhAGkAbABhAGIAbABlACAAdwBpAHQAaAAgAGEAIABGAEEAUQAgAGEAdAA6ACAAaAB0AHQAcABzADoALwAvAG8AcABlAG4AZgBvAG4AdABsAGkAYwBlAG4AcwBlAC4AbwByAGcAaAB0AHQAcABzADoALwAvAG8AcABlAG4AZgBvAG4AdABsAGkAYwBlAG4AcwBlAC4AbwByAGcAUgBvAGIAbwB0AG8ATQBlAGQAaQB1AG0AAAADAAAAAAAA/2oAZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgAIAAj//wAPAAEAAgAOAAAAAAAAAigAAgBZACUAPgABAEQAXgABAGoAagABAHAAcAABAHUAdQABAIEAgQABAIMAgwABAIYAhgABAIkAiQABAIsAlgABAJgAnwABAKEAowABAKUApgABAKgArQADALEAsQABALoAuwABAL8AvwABAMEAwQABAMMAxAABAMcAxwABAMsAywABAM0AzgABANAA0QABANMA0wABANoA3gABAOEA4QABAOUA5QABAOcA6QABAOsA+wABAP0A/QABAP8BAQABAQMBAwABAQgBCQABARYBGgABARwBHAABASABIgABASQBJwADASoBKwABATMBNAABATYBNgABATsBPAABAUEBRAABAUcBSAABAUsBTQABAVEBUQABAVQBWAABAV0BXgABAWIBYgABAWQBZAABAWgBaAABAWoBbAABAW4BbgABAXABcAABAdYB3AACAe0CAQABAgUCBQABAg4CDgABAhACEAABAhcCGQABAhsCHAABAh4CHgABAiICIgABAiQCJgABAiwCLAABAjECMwABAjUCNQABAkMCQwABAkYCRgABAkgCSAABAksCTgABAnoCfgABAo4CkwABApYC/gABAwEDwAABA8IDwgABA8QDzgABA9AD2QABA9sD9gABA/oD+gABA/wEAwABBAUEBwABBAoEDgABBBAEmwABBJ4EnwABBKEEogABBKQEpwABBLEFDQABBQ8FGQABBRwFKQABAAEAAwAAABAAAAAWAAAAIAABAAEArQACAAEAqACsAAAAAgACAKgArAAAASQBJwAFAAEAAAAaADQACgAHAEQAXABmAEwAVABwAHoABERGTFQAdGN5cmwAdGdyZWsAdGxhdG4AdAAEY3BzcABea2VybgBkbWFyawBsbWttawB0AAEAAAABAGIABAAAAAEAZAAEAAAAAQBoAAIACAACAMIEogACAAgAAgB6AJYABgAQAAEAWAAAAAYAEAABAFoAAgBqAAAAAAABAAAAAAACAAIAAQAAAAIAAwAEAAAAAgAFAAYAARXGAAUAJABIAAERLhISAAERNDgKAAERXBPSAAERbEsMAAERFhEWAAERHBEiAAERRBEmAAERVBE4AAERJAAEAAAAAhEOERQAAP//AAQAAAABAAIAAwACEVIABAAAEXYRngADAAMAAP+v/4gAAP8sAAAAAP+IAAAAAV4oAAQAAAHrGjgXYBdgHmYeDBewF+4YwBfSWooZABkAHCAYEhkAGQAYwBkiJ0IgAiZ4GAAYKB2yH5AYPhtKGN4YiBecMJYXfi10F7oXuhlqGIgX4B8qGKIYVBdmGKIbkBiIGMAgeCWyHQYYwB4MLHYudim8JEoXSBiiF4hRFBe6RCQrhC94GG4XThdUU/4XWhrSGmYg+kYWNFhAdDMKGQA9HEhIHbIoEBkAGQAb1hkAGQAZAD7GIYQZABoOJOwjJh7IKp4juBemKOYXZhmQQkpW/BiIGwwxzCIOGUQYiCKYGbodXBqcGUQeDBlqGAAYohnkGIglshemHbIXZhwgHCAcIBkAHbIXZhkAGQAYwBemHbIXZhdgNfoXYBdgF2AXeBxqHLgXcheSF2wXchdsF8QXbBfuGMAYwBjAGMAmeB4MHgweDB4MHgweDB4MF+4X0hfSF9IX0hkAGQAZABkAGQAYwBjAGMAYwBjAH5AY3hjeGN4Y3hjeGN4Y3hecF5wXnBecF7oZahlqGWoZahlqGKIYoh4MGN4eDBjeHgwY3hfuF+4X7hfuGMAX0hecF9IXnBfSF5wX0hecF9IXnBkAF7oZABkAGQAZABkAHCAYEhgSGBIYEhkAF7oZABe6GQAXuhe6GMAZahjAGWoYwBlqF+AX4BfgJngmeCZ4GCgfkBiiH5AYPhg+GD4XchdyF3gXbBdsF2wXbBdsF2wXbBdyF3IXchdyF3IXbBdsF2wXcheSF5IXkheSF3IXchdyF3geDBfSGQAZABjAH5AeDBewF9IYPhkAGQAcIBkAGQAYwBkiJngfkB2yGQAfkBe6GWoYohlqF9IlshkAGQAcIBwgG9YeDBewJbIX0hkAGQAYwBkiF+4meB2yGN4XnBlqGIgYohdmF5wXphiiGCgYKBgoH5AYohdgF2AXYBkAF7oeDBjeF9IXnBgAGKIX7h+QGKIZAB2yF2YZAB4MGN4eDBjeF9IXnBecF5wdshdmGMAZahlqGIgb1hiiG9YYohvWGKIeDBjeHgwY3h4MGN4eDBjeHgwY3h4MGN4eDBjeHgwY3h4MGN4eDBjeHgwY3h4MGN4X0hecF9IXnBfSF5wX0hecF9IXnBfSF5wX0hecF9IXnBkAGQAYwBlqGMAZahjAGWoYwBlqGMAZahjAGWoYwBlqGWofkBiiH5AYoh+QGKImeCWyF6YXuhoOJbIcIB+QGQAXuh4MGN4X0hkAGMAZahfgF7AYiBjAGMAZABe6HCAcIBgSGQAXuhkAF7oYwBkiGIgX4CZ4GAAYohgAGKIYKBg+GMAXbBdyF2wXeBdsF3IXeAACXgYABAAAYaZqYgApACgAAAAAAAAAAAASAAAAAAAAAAAAAAAAAAD/5P/jAAAAEQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQAA/+QAEf/lAAAAAAAAAAAAEgAAAAAAAAAA/+sAAAAAAAAAAAAA/+0AAP/V/9AAAP/qAAAAAAAAAAAAAAAAAAD/6f+T//X/6gAAAAAAAP/hAAAAAAAAAAAAAAAA/+0AAP/rAAAAAP/x/+4AAP/1AAD/9P/1/84AAP/v/43/gv/xAAAAAP/E/4gAAAAA/8f/xgAAAAAAAP+tAAAAAAAMABEAAP/JABL/rAAA/90AAP+IAAAAAAAAAAAAAAAAAAAAAAAAAAD/8QAAAAAAAAAAAAAAAAAAAAD/zwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/88AAAAA/+0AAAAAAAAAAAAA/+3/7//mAAAAAAAAABQAAAAAAAD/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/tAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//MAAAAAAAAAAAAAAAAAAAAA//IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/yAAAAAAAAAAAAAAAAAAAAAAAAAAD/8QAAAAAAAAAAAAAAAAAAAAD/iv/rAAAAAAAAAAAAAAAAAAAAAAAA//AAAAAAAAD/8AAAAAAAAAAA/4oAAAAA//MAAAAAAAAAAP/x//EAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAAAAAAAAAAAAAP9/AAAAAAAAAAAAAAAAAAAAAP/XAAAAAAAAAAAADwAAAAAAAAAAAAD/6gAAAAAAAAAAAAD/6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/6wAA/+oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/oQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/6EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/6gAAAAAAAP/uAAAAAAAA/+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/yAAAAAAAAAAAAAAAAAAAAAP/sAAAAAP+/AAAAAAAA/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9gAAAAAAAAAAP+//+P/2P+N/8v/u/+//9n/7P+r/6AAEgARAAAADf/GAAAAAP/p//D/8wARAAD/Jv/vABL/pwAA/+IAAAAAAAAAAAAA/6D/8/+rAAD/jQAA/+b/4f/xAAD/5wAA/+X/6f/YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP+bAAAAAAAAAAAAAAAA/6MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//UAAAAAAAAAAAAAAAAAAAAA/+P/8QAAAAAAAAAAAAAAAAAAAAAAAP/xAAAAAAAA//IAAAAAAAAAAP/jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/jAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+b/5wAAAAD/5wAA/+v/6//hAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADv+qAAAAAAARAAAAAAAR/9EAAAAAAAAAAAAAAAD/of/k/5r/ov+5/3v/df+s/7T/rwAAABAAEAAAAAD/mwAAAAD/s//w//EADwAA/xf/7QAQ/wn/vP/E/8sAAAAA/37/fP8Z//H/rwAA/6IAAP/FAAD/7P+IAAD/zv+4AAAAAAAAAAAAAAAAAAAAAP+sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/68AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/9QAAAAAAAAAAAAAAAP/rAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/sAAAAAAAAAAAAAP/lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/0r/vf8//zoAAP8//1D/Xv9sAAAAAAAHAAcAAAAA/0AAAAAA/2r/0QAAAAUAAP5hAAAAB/5JAAD/hv+SAAAAAP8P/wwAAAAAAAAAAP86AAAAAP+/AAAAE//yAAAAAP/f/38AE//V/wL/B//hAAAAAP9rAAAAAAAA/2v/gwAAAAAAAP9GAAAAAAAAAAAAAAAAAAAAAAAA/6sAEwAAABMAAP/hAAAAAP/V/+f/3//h/+0AAP/LAAAAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAD/fgAAAAD/xAAAAAAAAAAAAAAAAAAAAAAAAP/LAAD/1QAA/+v/5gAAAA3/7AAA/+v/7f/lAA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0AAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8sAAAAAP/tAAAAAAAAAAD/3P/mAAAAEgAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAD/cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAA/9T/8wAA/7X/2f/S/9L/5P/1/7QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP8jAAAAAP+vAAAAAAAAAAAAAAAAAAAAAAAA/7QAAP+1AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+8AAAAAAAAAAAAAAAAAAAAA/+wAAAAA/7QAAAAAAAD/uwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/1QAAAAAAAAAA//AAAAAAAAAAAAAA//AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/63/MwAA//YAAAAA/8D/yQAAAAAAAAAAAAAAAP/IAAAAAAAA//n/6//nAAAAAAAAAAAAAP/AAAAAAP+9/+n/of+lAAD/nP+9AAAAAAAAAAAAEgASAAAAAP/SAAAAAAAAAAAAAAAAAAD+cQAAAAD/bAAAAAD/ygAAAAD/u//pAAAAAAAAAAD/pQAA/+wAAAAAAAAAAAAA/+wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP/YAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/84AAAAAAAAAAAAAAAAAAAAA/3n/8QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/3QAAAAAAAP95AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/yf/lAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/+gAAAAAAAAAAP/zAAAAAAAAAAAAAAAAAAAAAAAA//MAAAAA/2cAAP/1//MAAAAP/6wAAAAAAAAAAP/aAAAAAAAAAAAAAAAAAAD/4v6fAAAAAAAAAAAAAP+oAAAAAP/HAAD/PgAA/6wAAP9nAAAAAAAAAAAAAP/yAAAAAAAAAAAAAAAAAAAAAP/sAAAAAP+/AAAAAAAA/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/9gAAAAAAAAAAP/FAAD/7P+IAAD/zv+4AAAAAAAAAAAAAAAAAAAAAP+sAAD/rwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/6//iAAAAAD/8f/uAAD/9QAA//T/9f/OAAD/7/+N/4L/8QAAAAD/xAAAAAAAAP/H/8YAAAAAAAD/rQAAAAAADAARAAD/yQAS/6wAAP/dAAD/iAAAAAEAAQCtAAEAAGekAAFnpAABABP/FwABACP/vAACAAEAqACsAAAAAQACABMAsgAFZ4hnjmeUZ5pnoAACAAIAqACsAAABJAEnAAUACQAAZ4oAAGeQAABnlgAAZ5wAAGeiAABnqAAAZ64AAGe0AABnugABABAABgALABAAEgCyAYUBhgGHAYgBiQGKAYsBjwGQA/cD+AACAAYAEAAQAAEAEgASAAEAsgCyAAIBhwGHAAEBiwGLAAEBjwGQAAEAAgAGAAYABgABAAsACwABALIAsgACAYUBhgABAYgBigABA/cD+AABAAIATAAlAD4AAABFAF4AGgCLAJYANACYAJsAQACdAJ0ARAC6ALsARQDBAMEARwDOAM4ASADbANsASQDdAN0ASgDvAO8ASwDyAPIATAEhASIATQFBAUIATwFMAU0AUQFYAVgAUwFiAWIAVAFkAWQAVQFqAWwAVgFuAW4AWQHtAgEAWgIOAg4AbwIYAhgAcAIbAhsAcQIsAiwAcgIyAjMAcwJDAkMAdQJGAkYAdgJIAkgAdwJLAk4AeAJ6An4AfAKOApMAgQKWAv4AhwMBAwEA8AMDA0YA8QNLA6gBNQOqA7oBkwO8A7wBpAO/A8ABpQPCA8IBpwPGA8YBqAPIA8kBqQPLA84BqwPQA9ABrwPSA9MBsAPVA9UBsgPXA9kBswPbA+ABtgPiA+cBvAPpA+wBwgPuA/YBxgP6A/oBzwP8BAAB0AQCBAIB1QQKBA4B1gQQBBAB2wQTBBcB3AQaBB4B4QQhBCIB5gQnBCgB6AQwBDAB6gQyBDIB6wQ0BDQB7AQ5BJMB7QSZBJsCSAShBKICSwSkBKUCTQSnBKcCTwSxBMACUATCBP4CYAUABQQCnQUGBQcCogUJBQkCpAULBQ0CpQUPBRcCqAUcBSkCsQACAE8AJQA+AAAARQBeABoAgQCBADQAgwCDADUAhgCGADYAiQCJADcAiwCWADgAmACdAEQAsQCxAEoAuwC7AEsAvwC/AEwAwQDBAE0AwwDDAE4AxwDHAE8AywDLAFAAzQDOAFEA0ADRAFMA0wDTAFUA2gDcAFYA3gDeAFkA4QDhAFoA5QDlAFsA5wDpAFwA6wD7AF8A/QD9AHAA/wEBAHEBAwEDAHQBCAEJAHUBFgEaAHcBHAEcAHwBIAEiAH0BKgErAIABQQFCAIIBSwFLAIQBWAFYAIUBYgFiAIYBZAFkAIcBaAFoAIgBagFsAIkBbgFuAIwB7QIBAI0CBQIFAKICEAIQAKMCFwIZAKQCHAIcAKcCHgIeAKgCIgIiAKkCJAImAKoCLAIsAK0CMQIxAK4CMwIzAK8CNQI1ALACQwJDALECRgJGALICSAJIALMCSwJOALQCegJ+ALgCjgKTAL0ClgL+AMMDAQOnASwDqQPAAdMDwgPCAesDxAPOAewD0APZAfcD2wP2AgED+gP6Ah0D/AQDAh4EBQQHAiYECgQOAikEEASYAi4EmwSbArcEngSfArgEoQSiAroEpASnArwEsQTsAsAE7gUNAvwFDwUWAxwFGAUZAyQFHAUpAyYAAQD7AAgACgAUABUAFgAXABgAGQAaABsAHAAdACUAJgAnACgAKQAqACsALAAtAC4ALwAwADEAMgAzADQANQA2ADcAOAA5ADoAOwA8AD0APgBlAGcAgQCDAIQAjACPAJEAkwCxALIAswC0ALUAtgC3ALgAuQC6ANIA0wDUANUA1gDXANgA2QDaANsA3ADdAN4A3wDgAOEA4gDjAOQA5QDmAOcA6ADpAS8BMwE1ATcBOQE7AUEBQwFFAUkBSwFMAVgBWQFxAbIBuAG9AcAClgKXApkCmwKcAp0CngKfAqACoQKiAqMCpAKlAqYCpwKoAqkCqgKrAqwCrQKuAq8CsAKxArICswK0ArUC0gLUAtYC2ALaAtwC3gLgAuIC5ALmAugC6gLsAu4C8ALyAvQC9gL4AvoC/AL+Av8DAQMDAwUDBwMJAwsDDQMPAxEDFAMWAxgDGgMcAx4DIAMiAyQDJgMoAyoDLAMuAzADMgM0AzYDOAM6AzwDPgNAA0EDQwNFA0cDSQOiA6MDpAOlA6YDpwOoA6oDqwOsA60DrgOvA7ADsQOyA7MDtAO1A7YDtwO4A7kDyQPKA8sDzAPNA84DzwPQA9ED0gPTA9QD1QPWA9cD2APZA9oD2wPcA90D3gPvA/ED8wP1BAoEDAQOBCMEKQQvBJkEngSiBSMFJQABAMQADgABAPb/zQABAMoAEwABAPb/3AABAFsACwABARz/8QABAfH/xwABAfH/8QABAfEADQACAPb/yAGG/6cAAgDK//QA9v/YAAIB8f+3Afb/8AACAPb/9QGG/7YAAgDt/6UBHP/uAAIBEQALAWz/5gACAPb/yAGG/6EAAwHw//UB8f/uA5z/9QADAEr/7gBb/+oB8f/wAAMASgARAFgAMgBbABEABAAN/+YAQf/0AGH/7wFN/+0ABAANABQAQQARAFb/4gBhABMABQBb/7MB8f95Afb/8QIA//ECTP/zAAUADQAPAEEADABW/+sAYQAOAkz/6QAFAFv/5QC4/8sAzf/kAgD/6wJM/+0ABgAQ/4QAEv+EAYf/hAGL/4QBj/+EAZD/hAAGAMr/6gDt/+4A9v+6AP7/+QE6/+wBbf/sAAYAyv/qAO3/7gD2/74A/v/5ATr/7AFt/+wABwBKAA0Avv/5AMYACwDH/+oAygAMAO3/yAEc//EABwCB/98Atf/zALf/8ADE/+oA2f/fAOb/4AFs/+AACAD2//AA/v/6AQn/8QEg//MBOv/xAWP/8wFl/+0Bbf/eAAgA2QAVAO0AFQFJ/+QBSv/lAUz/5AFi/+MBZP/iAWz/5AAIAFgADgCB/1YAvv/5AMT/xADH/9oA2f9xAO3/ngFf/9wACQD2/50A/v/rAQn/0wEg/9sBOv8+AUr/ugFj//ABZf/yAW3/UAAJAMr/6gDt/7gA9v/nAQn/8AEg//EBOv/rAWP/9QFt/+wBhv+kAAoABv/1AAv/9QGF//UBhv/1AYj/9QGJ//UBiv/1A/f/9QP4//UD+//1AAoABv/WAAv/1gGF/9YBhv/WAYj/1gGJ/9YBiv/WA/f/1gP4/9YD+//WAAoABv/qAAv/6gGF/+oBhv/qAYj/6gGJ/+oBiv/qA/f/6gP4/+oD+//qAAoA5v/DAPb/zwD+//ABOv/OAUn/5wFM/98BYv/RAWT/7AFs/6ABbf/RAAsAOP/RANL/0QDW/9EBOf/RAUX/0QMq/9EDLP/RAy7/0QPd/9EEk//RBNv/0QANAFz/8gBe//IA7v/yATT/8gFE//IBXv/yA0L/8gNE//IDRv/yA+b/8gQS//IEIP/yBOX/8gANAPb/mgD5/9YA/v/yAQn/0wEg/9sBOv8+AUj/1gFK/7oBY//wAWX/8gFt/1AENv/WBJb/1gAOAFz/7QBe/+0A7v/tAPb/sgE0/+0BRP/tAV7/7QNC/+0DRP/tA0b/7QPm/+0EEv/tBCD/7QTl/+0ADwDtABQA8gAQAPb/8AD5//AA/v/6AQEAEAEEABABOv/sAUj/8AFK/+IBUQAQAW3/8AFwABAENv/wBJb/8AARAC7/7gA5/+4Csf/uArL/7gKz/+4CtP/uAwH/7gMw/+4DMv/uAzT/7gM2/+4DOP/uAzr/7gPO/+4Efv/uBID/7gTd/+4AEQAu/+wAOf/sArH/7AKy/+wCs//sArT/7AMB/+wDMP/sAzL/7AM0/+wDNv/sAzj/7AM6/+wDzv/sBH7/7ASA/+wE3f/sABIA2f+uAOYAEgDr/+AA7f+tAO//1gD9/98BAf/SAQf/4AEc/84BLv/dATD/4gE4/+ABQP/gAUr/6QFN/9oBX/+9AWn/3wFsABEAEgBb/8EAuP/FAMr/tADq/9cA9v+5AP7/6QEJ/7IBHP/SASD/yAE6/6ABSv/FAVj/5AFj/8wBZf/MAW3/ywFu/+8CAP/mAkz/6AATAe7/7gHw//UB8f/xAfP/8gIP//ICE//yAiv/8gIt/+4CL//yA2j/7gOU//IDnP/1A53/7gOe/+4E7P/uBPr/7gT9/+4FEf/yBRb/7gATAe7/5QHw//EB8f/rAfP/6QIP/+kCE//pAiv/6QIt/+UCL//pA2j/5QOU/+kDnP/xA53/5QOe/+UE7P/lBPr/5QT9/+UFEf/pBRb/5QAVAFj/7wBb/98Amv/uALj/5QC5/9EAxAARAMr/yADZABMA5v/FAPb/ygE6/5QBSf9YAUr/fwFM/6UBTf/dAVj/8gFi/4sBZP/KAWz/cAFt/6IB8f/NABUAXP/tAO7/7QD2/6EA+f/RAP7/7wEJ/9MBIP/bATT/7QE6/z4BRP/tAUj/0QFK/7oBXv/tAWP/8AFl//IBbf9QA+b/7QQS/+0EIP/tBDb/0QSW/9EAFgC4/9QAvv/2AML/7QDEABEAyv/gAMz/5wDN/+UAzv/uANkAEgDq/+kA9v/XATr/1wFK/9MBTP/WAU3/xQFY/+cBYgANAWQADAFt/9YBbv/yAfb/6QJM/+kAFgAj/7wAWP/vAFv/3wCa/+4AuP/lALn/0QDEABEAyv/IANkAEwDm/8UA9v/KATr/lAFJ/1gBSv9/AUz/pQFN/90BWP/yAWL/iwFk/8oBbP9wAW3/ogHx/80AGAA6ABQAOwAZAD0AFgEZABQCtQAWAzwAGQM+ABYDQAAWA6cAFgO2ABYDuQAWA+8AGQPxABkD8wAZA/UAFgQGABQEDgAWBIwAFgSOABYEkAAWBKIAFgTeABQE4AAUBOIAGQAYADj/6wA9//MA0v/rANb/6wE5/+sBRf/rArX/8wMq/+sDLP/rAy7/6wM+//MDQP/zA6f/8wO2//MDuf/zA93/6wP1//MEDv/zBIz/8wSO//MEkP/zBJP/6wSi//ME2//rABkAU//oARj/6AGGAAkCx//oAsj/6ALJ/+gCyv/oAsv/6AMV/+gDF//oAxn/6APA/+gDxv/oA+L/6AQo/+gELP/oBGf/6ARp/+gEa//oBG3/6ARv/+gEcf/oBHP/6AR7/+gEvP/oABwACv/iAA0AFAAO/88AQQASAEr/6gBW/9gAWP/qAGEAEwBt/64AfP/NAIH/oACG/8EAif/AALj/0AC8/+oAvv/1AL//xgDAAA0Awv/pAMP/1gDG/+gAx/+6AMr/6QDM/8sAzf/aAM7/xwGO/9MCTP/NAB0AOP+7ADr/7QA9/9AA0v+7ANb/uwEZ/+0BOf+7AUX/uwK1/9ADKv+7Ayz/uwMu/7sDPv/QA0D/0AOn/9ADtv/QA7n/0APd/7sD9f/QBAb/7QQO/9AEjP/QBI7/0ASQ/9AEk/+7BKL/0ATb/7sE3v/tBOD/7QAgAAb/8gAL//IAWv/zAF3/8wC9//MA9v/1ARr/8wGF//IBhv/yAYj/8gGJ//IBiv/yAtD/8wLR//MDP//zA8L/8wPl//MD7v/zA/b/8wP3//ID+P/yA/v/8gQH//MED//zBDD/8wQy//MENP/zBI3/8wSP//MEkf/zBN//8wTh//MAIgBa//QAXP/yAF3/9ABe//MAvf/0AO7/8gEa//QBNP/yAUT/8gFe//IC0P/0AtH/9AM///QDQv/zA0T/8wNG//MDwv/0A+X/9APm//ID7v/0A/b/9AQH//QED//0BBL/8gQg//IEMP/0BDL/9AQ0//QEjf/0BI//9ASR//QE3//0BOH/9ATl//MAIgAG/8AAC//AADr/yADe/+sA4f/nAOb/wwD2/84A/v/wARn/yAE6/80BR//nAUn/5wFM/98BYv/RAWT/7AFs/6ABbf/QAYX/wAGG/8ABiP/AAYn/wAGK/8AD0f/rA/f/wAP4/8AD+//ABAb/yAQv/+sEMf/rBDP/6wQ1/+cElf/nBN7/yATg/8gAIgBa/9IAXf/SAL3/0gD2/6UA+f/hAP7/+gEJ/9MBGv/SASD/2wE6/00BSP/hAUr/uwFj//gBZf/zAW3/XwLQ/9IC0f/SAz//0gPC/9ID5f/SA+7/0gP2/9IEB//SBA//0gQw/9IEMv/SBDT/0gQ2/+EEjf/SBI//0gSR/9IElv/hBN//0gTh/9IAIwBa//QAXP/wAF3/9AC9//QA7f/vAO7/8ADy//MA/v/5AQT/8wEa//QBNP/wAUT/8AFR//MBXv/wAXD/8wLQ//QC0f/0Az//9APC//QD5f/0A+b/8APu//QD9v/0BAf/9AQP//QEEv/wBCD/8AQw//QEMv/0BDT/9ASN//QEj//0BJH/9ATf//QE4f/0ACQAOP/iADz/5ADS/+IA1P/kANb/4gDZ/+EA2v/kAN3/5ADe/+kA7f/kAPL/6wEE/+sBM//kATn/4gFD/+QBRf/iAVD/5AFR/+sBXf/kAWb/5AFv/+QBcP/rAyr/4gMs/+IDLv/iA7f/5APR/+kD3f/iA97/5AQR/+QEH//kBC//6QQx/+kEM//pBJP/4gTb/+IAJAAG//IAC//yAFr/9QBd//UAvf/1APb/9AD+//wBCf/1ARr/9QE6//UBbf/1AYX/8gGG//IBiP/yAYn/8gGK//IC0P/1AtH/9QM///UDwv/1A+X/9QPu//UD9v/1A/f/8gP4//ID+//yBAf/9QQP//UEMP/1BDL/9QQ0//UEjf/1BI//9QSR//UE3//1BOH/9QAoABD/LQAS/y0AJf/NALL/zQC0/80Ax//yAQ3/zQGH/y0Bi/8tAY//LQGQ/y0Cm//NApz/zQKd/80Cnv/NAp//zQKg/80Cof/NAtL/zQLU/80C1v/NA6L/zQOq/80D0v/NA/7/zQQU/80EFv/NBDr/zQQ8/80EPv/NBED/zQRC/80ERP/NBEb/zQRI/80ESv/NBEz/zQRO/80EUP/NBLX/zQAxADj/4wA8/+UAPf/kANL/4wDU/+UA1v/jANn/4gDa/+UA3f/lAN7/6QDy/+oBBP/qATP/5QE5/+MBQ//lAUX/4wFQ/+UBUf/qAV3/5QFm/+UBbP/kAW//5QFw/+oCtf/kAyr/4wMs/+MDLv/jAz7/5ANA/+QDp//kA7b/5AO3/+UDuf/kA9H/6QPd/+MD3v/lA/X/5AQO/+QEEf/lBB//5QQv/+kEMf/pBDP/6QSM/+QEjv/kBJD/5AST/+MEov/kBNv/4wAxAFb/cwBb/5IAbf4vAHz+qQCB/rYAhv8+AIn/SwC4/2cAvv+5AL//DwDD/vQAxv8rAMf+8QDK/1IAzP75AM3/AwDO/uwA2f9YAOYABQDq/70A6/9JAO3+/gDv/xMA9v9oAP3/DgD+/0YA//8TAQH/BwECABIBB/8OAQn/EQEc/x0BIP+sAS7/FQEw/zwBOP8OATr/agFA/0kBSv8MAUz/PwFN/vEBWP/AAV/+7wFj/zEBZf9fAWn/CgFsAAUBbf8wAW7/1QAyAAT/0QBW/7kAW//LAG3++gB8/0IAgf9JAIb/mQCJ/6EAuP+yAL7/3QC//34Aw/9uAMb/jgDH/2wAyv+lAMz/cQDN/3cAzv9pANn/qQDmAA8A6v/kAOv/oADt/3QA7/+AAPb/sgD9/30A/v+eAP//gAEB/3kBAgAPAQf/fQEJ/38BHP+GASD/2gEu/4EBMP+YATj/fQE6/7MBQP+gAUr/fAFM/5oBTf9sAVj/5gFf/2sBY/+SAWX/rQFp/3sBbAAPAW3/kQFu//IAMwA4/9kAOv/kADv/7AA9/90A0v/ZANb/2QEZ/+QBOf/ZAUX/2QIGAA4CCAAOAk4ADgK1/90DKv/ZAyz/2QMu/9kDPP/sAz7/3QNA/90DTgAOA08ADgNQAA4DUQAOA1IADgNTAA4DVAAOA2kADgNqAA4DawAOA6f/3QO2/90Duf/dA93/2QPv/+wD8f/sA/P/7AP1/90EBv/kBA7/3QSM/90Ejv/dBJD/3QST/9kEov/dBNv/2QTe/+QE4P/kBOL/7ATnAA4E7gAOBQYADgA1ABv/8gA4//EAOv/0ADz/9AA9//AA0v/xANT/9QDW//EA2v/0AN3/9QDe//MA5v/xARn/9AEz//QBOf/xAUP/9AFF//EBUP/1AV3/9AFi//IBZP/yAWb/9QFs//IBb//1ArX/8AMq//EDLP/xAy7/8QM+//ADQP/wA6f/8AO2//ADt//0A7n/8APR//MD3f/xA97/9AP1//AEBv/0BA7/8AQR//QEH//0BC//8wQx//MEM//zBIz/8ASO//AEkP/wBJP/8QSi//AE2//xBN7/9ATg//QANQBR//kAUv/5AFT/+QDB//kA7P/5AO0AFADw//kA8f/5APP/+QD0//kA9f/5APb/7QD4//kA+f/tAPr/+QD7//kA/P/bAP7/+QEA//kBBf/5ASv/+QE2//kBOv/tATz/+QE+//kBSP/tAUr/7QFT//kBVf/5AVf/+QFc//kBbf/tAsb/+QMO//kDEP/5AxL/+QMT//kDvP/5A+H/+QPj//kD6P/5A+3/+QP9//kEA//5BCT/+QQm//kENv/tBDj/+QSW/+0EmP/5BLT/+QTR//kE0//5ADgAJf/kADz/0gA9/9MAsv/kALT/5ADE/+IA2v/SAQ3/5AEz/9IBQ//SAV3/0gKb/+QCnP/kAp3/5AKe/+QCn//kAqD/5AKh/+QCtf/TAtL/5ALU/+QC1v/kAz7/0wNA/9MDov/kA6f/0wOq/+QDtv/TA7f/0gO5/9MD0v/kA97/0gP1/9MD/v/kBA7/0wQR/9IEFP/kBBb/5AQf/9IEOv/kBDz/5AQ+/+QEQP/kBEL/5ARE/+QERv/kBEj/5ARK/+QETP/kBE7/5ARQ/+QEjP/TBI7/0wSQ/9MEov/TBLX/5AA5AFH/7wBS/+8AVP/vAFz/8ADB/+8A7P/vAO3/7gDu//AA8P/vAPH/7wDz/+8A9P/vAPX/7wD2/+4A+P/vAPr/7wD7/+8A/v/vAQD/7wEF/+8BCf/0ASD/8QEr/+8BNP/wATb/7wE6/+8BPP/vAT7/7wFE//ABU//vAVX/7wFX/+8BXP/vAV7/8AFt/+8Cxv/vAw7/7wMQ/+8DEv/vAxP/7wO8/+8D4f/vA+P/7wPm//AD6P/vA+3/7wP9/+8EA//vBBL/8AQg//AEJP/vBCb/7wQ4/+8EmP/vBLT/7wTR/+8E0//vADwABv/DAAv/wwBK//EAWf/3AFr/2wBd/9sAm//3AL3/2wDC//UAxAAKAMb/8wDK/3IAy//3ARr/2wGF/8MBhv/DAYj/wwGJ/8MBiv/DAsz/9wLN//cCzv/3As//9wLQ/9sC0f/bAzH/9wMz//cDNf/3Azf/9wM5//cDO//3Az//2wO+//cDwv/bA8X/9wPH//cD5f/bA+7/2wP2/9sD9//DA/j/wwP7/8MEB//bBA//2wQw/9sEMv/bBDT/2wR///cEgf/3BIP/9wSF//cEh//3BIn/9wSL//cEjf/bBI//2wSR/9sEwP/3BN//2wTh/9sAPwAn//MAK//zADP/8wA1//MAg//zAJP/8wCY//MAs//zAMQADQDT//MBCP/zARf/8wEb//MBHf/zAR//8wEh//MBQf/zAWr/8wJg//MCYf/zAmP/8wJk//MCov/zAqz/8wKt//MCrv/zAq//8wKw//MC2P/zAtr/8wLc//MC3v/zAuz/8wLu//MC8P/zAvL/8wMU//MDFv/zAxj/8wNJ//MDpv/zA7P/8wPZ//MD3P/zBAn/8wQM//MEJ//zBCn/8wQr//MEZv/zBGj/8wRq//MEbP/zBG7/8wRw//MEcv/zBHT/8wR2//MEeP/zBHr/8wR8//MEu//zBNT/8wBAAEf/7ABI/+wASf/sAEv/7ABV/+wAlP/sAJn/7AC7/+wAyP/sAMn/7AD3/+wBA//sAR7/7AEi/+wBQv/sAWD/7AFh/+wBa//sAr3/7AK+/+wCv//sAsD/7ALB/+wC2f/sAtv/7ALd/+wC3//sAuH/7ALj/+wC5f/sAuf/7ALp/+wC6//sAu3/7ALv/+wC8f/sAvP/7AO6/+wD4P/sA+T/7APn/+wEAv/sBAj/7AQN/+wEG//sBB3/7AQe/+wEKv/sBDn/7ART/+wEVf/sBFf/7ARZ/+wEW//sBF3/7ARf/+wEYf/sBHX/7AR3/+wEef/sBH3/7AS4/+wExf/sBMf/7ABAACf/5gAr/+YAM//mADX/5gCD/+YAk//mAJj/5gCz/+YAuP/CAMQAEADT/+YBCP/mARf/5gEb/+YBHf/mAR//5gEh/+YBQf/mAWr/5gJg/+YCYf/mAmP/5gJk/+YCov/mAqz/5gKt/+YCrv/mAq//5gKw/+YC2P/mAtr/5gLc/+YC3v/mAuz/5gLu/+YC8P/mAvL/5gMU/+YDFv/mAxj/5gNJ/+YDpv/mA7P/5gPZ/+YD3P/mBAn/5gQM/+YEJ//mBCn/5gQr/+YEZv/mBGj/5gRq/+YEbP/mBG7/5gRw/+YEcv/mBHT/5gR2/+YEeP/mBHr/5gR8/+YEu//mBNT/5gBHABAABAASAAQAR//nAEj/5wBJ/+cAS//nAFX/5wCU/+cAmf/nALv/5wDEAA8AyP/nAMn/5wD3/+cBA//nAR7/5wEi/+cBQv/nAWD/5wFh/+cBa//nAYcABAGLAAQBjwAEAZAABAK9/+cCvv/nAr//5wLA/+cCwf/nAtn/5wLb/+cC3f/nAt//5wLh/+cC4//nAuX/5wLn/+cC6f/nAuv/5wLt/+cC7//nAvH/5wLz/+cDuv/nA+D/5wPk/+cD5//nBAL/5wQI/+cEDf/nBBv/5wQd/+cEHv/nBCr/5wQ5/+cEU//nBFX/5wRX/+cEWf/nBFv/5wRd/+cEX//nBGH/5wR1/+cEd//nBHn/5wR9/+cEuP/nBMX/5wTH/+cATQAGABAACwAQAA0AFABBABIAR//oAEj/6ABJ/+gAS//oAFX/6ABhABMAlP/oAJn/6AC7/+gAyP/oAMn/6AD3/+gBA//oAR7/6AEi/+gBQv/oAWD/6AFh/+gBa//oAYUAEAGGABABiAAQAYkAEAGKABACvf/oAr7/6AK//+gCwP/oAsH/6ALZ/+gC2//oAt3/6ALf/+gC4f/oAuP/6ALl/+gC5//oAun/6ALr/+gC7f/oAu//6ALx/+gC8//oA7r/6APg/+gD5P/oA+f/6AP3ABAD+AAQA/sAEAQC/+gECP/oBA3/6AQb/+gEHf/oBB7/6AQq/+gEOf/oBFP/6ARV/+gEV//oBFn/6ARb/+gEXf/oBF//6ARh/+gEdf/oBHf/6AR5/+gEff/oBLj/6ATF/+gEx//oAE8ARwABAEgAAQBJAAEASwABAFUAAQCUAAEAmQABALsAAQDIAAEAyQABAO0AKwDyABQA9v/jAPcAAQD5//AA/P/mAP7/9QEDAAEBBAAUAR4AAQEiAAEBOv/TAUIAAQFI//ABSv/fAVEAFAFgAAEBYQABAWsAAQFt/+MBcAAUAr0AAQK+AAECvwABAsAAAQLBAAEC2QABAtsAAQLdAAEC3wABAuEAAQLjAAEC5QABAucAAQLpAAEC6wABAu0AAQLvAAEC8QABAvMAAQO6AAED4AABA+QAAQPnAAEEAgABBAgAAQQNAAEEGwABBB0AAQQeAAEEKgABBDb/8AQ5AAEEUwABBFUAAQRXAAEEWQABBFsAAQRdAAEEXwABBGEAAQR1AAEEdwABBHkAAQR9AAEElv/wBLgAAQTFAAEExwABAFMAOP++AFH/9QBS//UAVP/1AFr/7wBd/+8Avf/vAMH/9QDS/74A1v++AOb/yQDs//UA8P/1APH/9QDz//UA9P/1APX/9QD2/98A+P/1APr/9QD7//UA/v/1AQD/9QEF//UBCf/tARr/7wEg/+sBK//1ATb/9QE5/74BOv/fATz/9QE+//UBRf++AUz/6QFT//UBVf/1AVf/9QFc//UBY//1AW3/4ALG//UC0P/vAtH/7wMO//UDEP/1AxL/9QMT//UDKv++Ayz/vgMu/74DP//vA7z/9QPC/+8D3f++A+H/9QPj//UD5f/vA+j/9QPt//UD7v/vA/b/7wP9//UEA//1BAf/7wQP/+8EJP/1BCb/9QQw/+8EMv/vBDT/7wQ4//UEjf/vBI//7wSR/+8Ek/++BJj/9QS0//UE0f/1BNP/9QTb/74E3//vBOH/7wBoADj/MwA6/8gAPP/wAD3/rABR/+8AUv/vAFT/7wDB/+8A0v8zANT/9QDW/zMA2v/wAN3/9QDe/+sA4f/mAOb/wgDs/+8A8P/vAPH/7wDz/+8A9P/vAPX/7wD2/84A+P/vAPr/7wD7/+8A/v/vAQD/7wEF/+8BGf/IASv/7wEz//ABNv/vATn/MwE6/80BPP/vAT7/7wFD//ABRf8zAUf/5gFJ/+YBTP/fAVD/9QFT/+8BVf/vAVf/7wFc/+8BXf/wAWL/0AFk/+sBZv/1AWz/nwFt/9ABb//1ArX/rALG/+8DDv/vAxD/7wMS/+8DE//vAyr/MwMs/zMDLv8zAz7/rANA/6wDp/+sA7b/rAO3//ADuf+sA7z/7wPR/+sD3f8zA97/8APh/+8D4//vA+j/7wPt/+8D9f+sA/3/7wQD/+8EBv/IBA7/rAQR//AEH//wBCT/7wQm/+8EL//rBDH/6wQz/+sENf/mBDj/7wSM/6wEjv+sBJD/rAST/zMElf/mBJj/7wSi/6wEtP/vBNH/7wTT/+8E2/8zBN7/yATg/8gAaABH/7QASP+0AEn/tABL/7QATAAUAE8AFABQABQAU/96AFX/tABX/2QAWwALAJT/tACZ/7QAu/+0AMj/tADJ/7QA9/+0AQP/tAEY/3oBHv+0ASL/tAFC/7QBYP+0AWH/tAFr/7QB3P9kAr3/tAK+/7QCv/+0AsD/tALB/7QCx/96Asj/egLJ/3oCyv96Asv/egLZ/7QC2/+0At3/tALf/7QC4f+0AuP/tALl/7QC5/+0Aun/tALr/7QC7f+0Au//tALx/7QC8/+0AxX/egMX/3oDGf96AyH/ZAMj/2QDJf9kAyf/ZAMp/2QDuv+0A8D/egPG/3oD4P+0A+L/egPk/7QD5/+0A+n/ZAQC/7QECP+0BA3/tAQb/7QEHf+0BB7/tAQo/3oEKv+0BCz/egQ5/7QEU/+0BFX/tARX/7QEWf+0BFv/tARd/7QEX/+0BGH/tARn/3oEaf96BGv/egRt/3oEb/96BHH/egRz/3oEdf+0BHf/tAR5/7QEe/96BH3/tAS4/7QEvP96BMX/tATH/7QEyQAUBMsAFATNABQE2v9kAr9EEEMCQzJB9EQcQ/JD+EMIRChC/ER8Qh5DJkQERRhEskEuRDpC9kPIROJE6EMUQ+ZD4ELYRBZBNEM4Q8JEIkE6Q/5D2kQuQyBEgkQuQyxECkQ0RLhBQERAQw5CbERGRO5DGkPsQ7xCckPCQUZELkLqQUxBUkQERApBWEFeQWRBakN6Q4BDnkRGQ0RC0kLeQuRC8ENKQXBDUEF2QXxBgkG4QYhDzkPUQz5BjkGUQaBBmkIeQaBFJEWiRWxFnEQKQsxFZkUwQrRBpkVgRZBFKkVaQqJFQkU8RTZFeEKEQaxFHkVyQbJBuEWEQb5FVEHERIJCfkV+RU5FSEMgQcpELkHQRC5B1kWKQdxFkEHiRSpB9EH0Q9pDyEJsRBBEEEQQRBBEEEQQRBBB6EQcRBxEHEQcRChEKEQoRChEBEUYRRhFGEUYRRhE4kTiROJE4kPgRBZEFkQWRBZEFkQWRBZB7kQiRCJEIkQiRC5ELkQuRC5ECkQ0RDRENEQ0RDRERkRGREZERkO8Q7xEEEQWRBBEFkQQRBZDMkM4QzJDOEMyQzhDMkM4QfRDwkQcRCJEHEQiRBxEIkQcRCJEHEQiQ/hD/kP4Q/5D+EP+QfpD/kMIQ9pEKEQuRChELkQoRC5CAEQuRChC/EIGQgxCHkQuQhJCGEIeRC5CHkQuRARECkIkQipEBEQKRApFGEQ0RRhENEUYRDREOkRAQjBCNkQ6REBC9kMOQvZDDkI8QkJCSEJOQvZDDkJUQlpCYEJmQ8hCbETiREZE4kRGROJERkTiREZE4kRGROJERkMUQxpD4EO8Q+BC2EJyQthCckLYQnJCfkJ+RWZFSEVIRUhFSEVIRUhFSEJ4RVRFVEVURVRFNkU2RTZFNkUqRZBFkEWQRZBFkELMQsxCzELMRaJFSEVIRUhFfkV+RX5FfkJ+RVRFVEVURVRFVEKEQoRChEKKRXhFNkU2RTZCkEU2RTxClkKiQpxCokKiRSpCqEUqRZBFkEWQQrRCrkK0RTBFMEK6RTBCwEVmQsZCzELMQsxCzELMQsxFnEWiRaJFJEUkRSREEEQcQwhEKEUYQ+BC0kQQQwJEHELYQwhEKER8QyZEBEUYRLJDyEPgQ+ZEKEPgQt5C5ELqRDRE7kQ0QvBEHEL2RChEKEL8RHxEEEMCRBxDJkMIRRhEskMyQ8hD5kQWRCJENES4QzhDvEPsRCJDDkQuRC5DIEO8QxRDGkMUQxpDFEMaQ+BDvEMgQyZDLEQQRBZEHEQiQ0pDUEMyQzhD4EQoRChEEEQWRBBEFkQcRCJDPkNEQ0RDSkNQRRhENEO8Q7xDvEPCQ1ZDXEQQRBZEEEQWRBBEFkQQRBZEEEQWQ1ZDXEQQRBZEEEQWRBBEFkQQRBZDVkNcQ2JDqkQcRCJEHEQiRBxEIkQcRCJEHEQiRBxEIkNiQ6pEKEQuQ2hFzENuQ3RFGEQ0RRhENEUYRDRFGEQ0RRhENENuQ3RDekOAQ3pDgEN6Q4BDekOAQ4ZDjEOSQ5hE4kRGQ55ERkOeREZDnkRGQ55ERkOkQ6pDsEO2Q+BDvEPgQ7xDwkPIQ85D1EPaRIJD4EPmQ+xD8kP4Q/5EBEQKRBBEFkQcRCJEKEQuRRhENEQ6REBE4kRGRExEUkRYRF5EZERqRHBEdkR8RIJEiESORJRFzESaRKBEpkSsRRhEskS4RL5ExETKRNBE1kTcROJE6ETuRPRE+kUARQZFDEUSRRhFSEVURXhFNkWQRaJFHkVIRU5FVEUkRXhFNkVCRVpFKkWQRWBFZkWiRWxFNkWiRVRFMEU2RTZFPEVCRUhFTkVURVpFeEWQRWBFfkVmRWxFckV4RX5FokWERYpFkEWWRZxFnEWcRaJFqEWuRbRFukXARcZFzABqADj/5gA6/+cAPP/yAD3/5wBR//EAUv/xAFT/8QBc//EAwf/xANL/5gDW/+YA2v/yAN7/7gDh/+gA5v/mAOz/8QDu//EA8P/xAPH/8QDz//EA9P/xAPX/8QD2/9AA+P/xAPr/8QD7//EA/v/xAQD/8QEF//EBGf/nASv/8QEz//IBNP/xATb/8QE5/+YBOv/OATz/8QE+//EBQ//yAUT/8QFF/+YBR//oAUn/6AFT//EBVf/xAVf/8QFc//EBXf/yAV7/8QFi/+cBZP/tAWz/5gFt/9ACtf/nAsb/8QMO//EDEP/xAxL/8QMT//EDKv/mAyz/5gMu/+YDPv/nA0D/5wOn/+cDtv/nA7f/8gO5/+cDvP/xA9H/7gPd/+YD3v/yA+H/8QPj//ED5v/xA+j/8QPt//ED9f/nA/3/8QQD//EEBv/nBA7/5wQR//IEEv/xBB//8gQg//EEJP/xBCb/8QQv/+4EMf/uBDP/7gQ1/+gEOP/xBIz/5wSO/+cEkP/nBJP/5gSV/+gEmP/xBKL/5wS0//EE0f/xBNP/8QTb/+YE3v/nBOD/5wBrACUADwA4/+YAOv/mADwADgA9/+YAsgAPALQADwDS/+YA1AAOANb/5gDZABMA2gAOAN0ADgDeAAsA4f/lAOb/5gDn//QA7QASAPIADwD2/+cA+f/oAP7/9wEEAA8BDQAPARn/5gEzAA4BOf/mATr/5wFDAA4BRf/mAUf/5QFI/+gBSf/lAUr/6AFM/+QBUAAOAVEADwFdAA4BYv/mAWT/5gFmAA4BbP/mAW3/5wFvAA4BcAAPApsADwKcAA8CnQAPAp4ADwKfAA8CoAAPAqEADwK1/+YC0gAPAtQADwLWAA8DKv/mAyz/5gMu/+YDPv/mA0D/5gOiAA8Dp//mA6oADwO2/+YDtwAOA7n/5gPRAAsD0gAPA93/5gPeAA4D9f/mA/4ADwQG/+YEDv/mBBEADgQUAA8EFgAPBB8ADgQvAAsEMQALBDMACwQ1/+UENv/oBDoADwQ8AA8EPgAPBEAADwRCAA8ERAAPBEYADwRIAA8ESgAPBEwADwROAA8EUAAPBIz/5gSO/+YEkP/mBJP/5gSV/+UElv/oBKL/5gS1AA8E2//mBN7/5gTg/+YAdQAG/7oAC/+6ADj/MwA6/8cAPP/xAD3/qwBR/+4AUv/uAFT/7gBc/9cAwf/uANL/MwDW/zMA2v/xAN7/6wDh/+UA5v/DAOz/7gDu/9cA8P/uAPH/7gDz/+4A9P/uAPX/7gD2/8wA+P/uAPr/7gD7/+4A/v/uAQD/7gEF/+4BGf/HASv/7gEz//EBNP/XATb/7gE5/zMBOv/JATz/7gE+/+4BQ//xAUT/1wFF/zMBR//lAUn/5QFM/98BU//uAVX/7gFX/+4BXP/uAV3/8QFe/9cBYv/QAWT/6wFs/6ABbf/NAYX/ugGG/7oBiP+6AYn/ugGK/7oCtf+rAsb/7gMO/+4DEP/uAxL/7gMT/+4DKv8zAyz/MwMu/zMDPv+rA0D/qwOn/6sDtv+rA7f/8QO5/6sDvP/uA9H/6wPd/zMD3v/xA+H/7gPj/+4D5v/XA+j/7gPt/+4D9f+rA/f/ugP4/7oD+/+6A/3/7gQD/+4EBv/HBA7/qwQR//EEEv/XBB//8QQg/9cEJP/uBCb/7gQv/+sEMf/rBDP/6wQ1/+UEOP/uBIz/qwSO/6sEkP+rBJP/MwSV/+UEmP/uBKL/qwS0/+4E0f/uBNP/7gTb/zME3v/HBOD/xwB2AEf/8ABI//AASf/wAEv/8ABT/94AVf/wAJT/8ACZ//AAu//wAMj/8ADJ//AA9//wAQP/8AEY/94BHP/rAR7/8AEi//ABQv/wAWD/8AFh//ABa//wAfb/6wH4/+sCAP/pAgf/6wIQ/+sCLP/rAjX/6wJM/+sCvf/wAr7/8AK///ACwP/wAsH/8ALH/94CyP/eAsn/3gLK/94Cy//eAtn/8ALb//AC3f/wAt//8ALh//AC4//wAuX/8ALn//AC6f/wAuv/8ALt//AC7//wAvH/8ALz//ADFf/eAxf/3gMZ/94DVf/rA1//6wNg/+sDYf/rA2L/6wNj/+sDbP/rA23/6wNu/+sDb//rA3b/6wN3/+sDeP/rA3n/6wOJ/+sDiv/rA4v/6wO6//ADwP/eA8b/3gPg//AD4v/eA+T/8APn//AEAv/wBAj/8AQN//AEG//wBB3/8AQe//AEKP/eBCr/8AQs/94EOf/wBFP/8ARV//AEV//wBFn/8ARb//AEXf/wBF//8ARh//AEZ//eBGn/3gRr/94Ebf/eBG//3gRx/94Ec//eBHX/8AR3//AEef/wBHv/3gR9//AEuP/wBLz/3gTF//AEx//wBOv/6wUN/+sFEP/rBRX/6wB8AAb/2gAL/9oAR//wAEj/8ABJ//AAS//wAFX/8ABZ/+8AWv/cAF3/3ACU//AAmf/wAJv/7wC7//AAvf/cAML/7ADEAA8Axv/qAMj/8ADJ//AAyv/IAMv/7wDM/+cA9//wAQP/8AEa/9wBHv/wASL/8AFC//ABYP/wAWH/8AFr//ABhf/aAYb/2gGI/9oBif/aAYr/2gK9//ACvv/wAr//8ALA//ACwf/wAsz/7wLN/+8Czv/vAs//7wLQ/9wC0f/cAtn/8ALb//AC3f/wAt//8ALh//AC4//wAuX/8ALn//AC6f/wAuv/8ALt//AC7//wAvH/8ALz//ADMf/vAzP/7wM1/+8DN//vAzn/7wM7/+8DP//cA7r/8AO+/+8Dwv/cA8X/7wPH/+8D4P/wA+T/8APl/9wD5//wA+7/3AP2/9wD9//aA/j/2gP7/9oEAv/wBAf/3AQI//AEDf/wBA//3AQb//AEHf/wBB7/8AQq//AEMP/cBDL/3AQ0/9wEOf/wBFP/8ARV//AEV//wBFn/8ARb//AEXf/wBF//8ARh//AEdf/wBHf/8AR5//AEff/wBH//7wSB/+8Eg//vBIX/7wSH/+8Eif/vBIv/7wSN/9wEj//cBJH/3AS4//AEwP/vBMX/8ATH//AE3//cBOH/3ACMAAb/ygAL/8oAOP/SADr/1AA8//QAPf/TAFH/4gBS/+IAVP/iAFr/5gBc/+8AXf/mAL3/5gDB/+IA0v/SANb/0gDa//QA3v/tAOH/4QDm/9QA7P/iAO7/7wDw/+IA8f/iAPP/4gD0/+IA9f/iAPb/yQD4/+IA+v/iAPv/4gD+/9EBAP/iAQX/4gEJ/+UBGf/UARr/5gEg/+MBK//iATP/9AE0/+8BNv/iATn/0gE6/8QBPP/iAT7/4gFD//QBRP/vAUX/0gFH/+EBSf/hAVP/4gFV/+IBV//iAVz/4gFd//QBXv/vAWL/1AFj//UBZP/nAWz/qgFt/8kBhf/KAYb/ygGI/8oBif/KAYr/ygK1/9MCxv/iAtD/5gLR/+YDDv/iAxD/4gMS/+IDE//iAyr/0gMs/9IDLv/SAz7/0wM//+YDQP/TA6f/0wO2/9MDt//0A7n/0wO8/+IDwv/mA9H/7QPd/9ID3v/0A+H/4gPj/+ID5f/mA+b/7wPo/+ID7f/iA+7/5gP1/9MD9v/mA/f/ygP4/8oD+//KA/3/4gQD/+IEBv/UBAf/5gQO/9MED//mBBH/9AQS/+8EH//0BCD/7wQk/+IEJv/iBC//7QQw/+YEMf/tBDL/5gQz/+0ENP/mBDX/4QQ4/+IEjP/TBI3/5gSO/9MEj//mBJD/0wSR/+YEk//SBJX/4QSY/+IEov/TBLT/4gTR/+IE0//iBNv/0gTe/9QE3//mBOD/1ATh/+YAmAAlABAAJ//oACv/6AAz/+gANf/oADj/4AA6/+AAPf/fAIP/6ACT/+gAmP/oALIAEACz/+gAtAAQANL/4ADT/+gA1AAQANb/4ADZABQA3QAQAOH/4QDm/+AA7QATAPIAEAD5/+ABBAAQAQj/6AENABABF//oARn/4AEb/+gBHf/oAR//6AEh/+gBOf/gAUH/6AFF/+ABR//hAUj/4AFJ/+EBSv/gAU3/4QFQABABUQAQAVj/6QFi/98BZP/eAWYAEAFq/+gBbP/fAW7/8gFvABABcAAQAmD/6AJh/+gCY//oAmT/6AKbABACnAAQAp0AEAKeABACnwAQAqAAEAKhABACov/oAqz/6AKt/+gCrv/oAq//6AKw/+gCtf/fAtIAEALUABAC1gAQAtj/6ALa/+gC3P/oAt7/6ALs/+gC7v/oAvD/6ALy/+gDFP/oAxb/6AMY/+gDKv/gAyz/4AMu/+ADPv/fA0D/3wNJ/+gDogAQA6b/6AOn/98DqgAQA7P/6AO2/98Duf/fA9IAEAPZ/+gD3P/oA93/4AP1/98D/gAQBAb/4AQJ/+gEDP/oBA7/3wQUABAEFgAQBCf/6AQp/+gEK//oBDX/4QQ2/+AEOgAQBDwAEAQ+ABAEQAAQBEIAEAREABAERgAQBEgAEARKABAETAAQBE4AEARQABAEZv/oBGj/6ARq/+gEbP/oBG7/6ARw/+gEcv/oBHT/6AR2/+gEeP/oBHr/6AR8/+gEjP/fBI7/3wSQ/98Ek//gBJX/4QSW/+AEov/fBLUAEAS7/+gE1P/oBNv/4ATe/+AE4P/gAzQ9bjv6OWY8Bj16O441uDwSOqQ4uDwqPDY8QjxOPMA7+jMYPGY8cjx+PIo8nDyoO3w7djy0PXQ8ADlsPAw9gDLENb48GDqqOOg8MDw8PEg8VDxUONAyyjxsPHg8hDr4PKI8rjuCOzo8ujmKMtA5kDLWMtwy4j2SOIgy6DLuPE48VDL0MvozADMGOuw68jsuOzQ0kjmoO2o4djuIOHw4gjMMOJo5SDigO/QzEjMYMx45WjMkMyo7XjMwMzYzPDNCM0g7cDNOM1Q5YDNaM2AzZjNsM3IzeDtYM34zhDtkM5YzijOQOWwzljOcM6IzqDOuM7Q58Dn2M7ozwDPGM8wz0jPYM94z5DPqM/Az9jP8NAI0CDQONCA0FDQaNCA9ID04PSY0JjQsOEw9ID1WPMY0Mj0aPRQ8zD0ON/I8xjzwPOQ9MjfCNDg9AjQ+NEQ9LDRKNFA0VjRcNGI0aDRuNHQ0ejSANIY9jDSMPDA3FD2GPQI9hjSSNJI9kj2SPZI0mDSeNKQ9FDSqPMw8BjwGPBg8fjyENLA0sDpcNLY5fjS8PW45ZjkwOTA6jDimNMI0wjTIOLI0zjTUNNQ6vDTaOeQ04DTgNOY07DkSNPI08jpiNPg5hDT+PXQ5bDk8OTw6kjjWNQQ1BDUKOOI1EDumO6Y6wjUWOeo1HDUcNSI1KDkYOiY1LjU0Omg6bj1uPXQ1OjVANUY1TDVSNVg1XjVkNWo8DDVwNXY5ljmcNXw1gj16PYA1iDWONZQ1mjWgNaY1rDWyNbg1vjXENco10DXWNdw14jXoNe46pDqqNfQ1+jYAPCo8MDYGNgw8Njw8PDY8PDw2PDw7oDumPE48VDYSNhg8VDYeNiQ2KjYwNjY2PDZCNkg8ZjxsNk42VDZaNmA2ZjZsPHI8eDxyPHg2cjZ4PH48hDx+PIQ2fjyENoQ2ijaQNpY2nDaiNqg2rja0Nro8ijr4NsA2xjbMNtI4cDbYNt425DbqNvA29jb8NwI3CDcONxQ3FD0gN3o3ejeANxo3IDcmPYY9hjcsNyw3MjzYNzg3ODc+POo3RD1QPVA3SjdQN1Y3XDdcN2I3aD1oN243dD2GN3o3gDeGN4w3kjeYN543pD2MN6o3sDe2N7w3wjfIN8431DfaPOQ34DfmPMY37DfyN/I38jf4PMw3/jgEOAo4EDz2PMY4FjgcOCI9VjgoPSA4aj0gOC44NDg6OEA4RjhMOFI4WDzSOF44ZDhqPW49ejwSOqQ8wDt2OII9bjv6PXo8tDwSOqQ8KjxCPE48wDv6PH47djt8OLI4cDh2O4g4fDiCOJo4iDxUPKI4jjiUPFQ4mjigOKY4rDxyOqQ4sji4PB44vj1uO/o7aj16OMQ8QjwSPMA7+jlmPH47fD10PYA4yjxUONA5bDs6O4I41jjcPHg6qjjiOOg47jj0OPo5ADj6OQA5BjkMORI5GDkeOSQ5Kj1uPXQ5MDk2OTw5QjlIOU45VDlaOWA5ZjlsO3Y6pDlyOXg6pDpoOm45fjmEOYo5kDmWOZw5ojmoOa45tDm6OcA5xjnMOdI52DneOeQ56jnwOfY5/DoCOgg6DjoUOho6IDomOiw6Mjo4Oj46RDpKPAw9bj10OlA6Vj1uPXQ9bj10PW49dD1uPXQ6XDpiPW49dD1uPXQ9bj10PW49dDpoOm49ej2AOnQ6ejqAOoY9ej2APXo9gD16PYA9ej2AOow6kjqYOp46pDqqPMA8VDqwOrY8wDxUPMA8VDzAPFQ8wDxUOrw6wjrIOs46yDrOOtQ62jrgOuY67DryPIo6+Dr+OwQ7CjsQOwo7EDsWOxw7IjsoOy47NDt2Ozo7QDtGO0w7UjwMPH47WDteO2Q7ajtwPBg7ajtwPDA7djt8O4I7iDuOO5Q7mjugO6Y7rDuyO7g7vjvEO8o70DvWO9w74jvoO+479Dv6PAA8BjwMPAY8DDwSPBg8HjwkPCo8MDw2PDw8QjxIPE48VDzAPFo8YDxmPGw8cjx4PH48hDyKPJA8ljycPKI8qDyuPLQ8ujzAPYY9jD0yPOQ9FD04PYY9Aj2MPSA9MjzkPMY9DjzMPRQ9Gj0gPTg9JjzqPNI82DzePVY85DzqPPA89jz8PYY9Aj0CPYw9CD0OPTI9FD0aPYY9ID0mPSw9Mj2GPTg9Pj1EPUo9UD1WPVw9XD1iPWg9bj10PXo9gD2GPYw9kgC6AEf/3ABI/9wASf/cAEv/3ABR/+EAUv/hAFP/1gBU/+EAVf/cAFn/3QBa/+EAXf/hAJT/3ACZ/9wAm//dALv/3AC9/+EAvv/1AL//5gDB/+EAwv/rAMP/6QDF//AAxv/nAMj/3ADJ/9wAyv/jAMv/3QDM/84Azf/UAM7/2wDs/+EA8P/hAPH/4QDz/+EA9P/hAPX/4QD3/9wA+P/hAPr/4QD7/+EA/v/hAQD/4QED/9wBBf/hARj/1gEa/+EBHv/cASL/3AEr/+EBNv/hATz/4QE+/+EBQv/cAVP/4QFV/+EBV//hAVz/4QFg/9wBYf/cAWv/3AK9/9wCvv/cAr//3ALA/9wCwf/cAsb/4QLH/9YCyP/WAsn/1gLK/9YCy//WAsz/3QLN/90Czv/dAs//3QLQ/+EC0f/hAtn/3ALb/9wC3f/cAt//3ALh/9wC4//cAuX/3ALn/9wC6f/cAuv/3ALt/9wC7//cAvH/3ALz/9wDDv/hAxD/4QMS/+EDE//hAxX/1gMX/9YDGf/WAzH/3QMz/90DNf/dAzf/3QM5/90DO//dAz//4QO6/9wDvP/hA77/3QPA/9YDwv/hA8X/3QPG/9YDx//dA+D/3APh/+ED4v/WA+P/4QPk/9wD5f/hA+f/3APo/+ED7f/hA+7/4QP2/+ED/f/hBAL/3AQD/+EEB//hBAj/3AQN/9wED//hBBv/3AQd/9wEHv/cBCT/4QQm/+EEKP/WBCr/3AQs/9YEMP/hBDL/4QQ0/+EEOP/hBDn/3ART/9wEVf/cBFf/3ARZ/9wEW//cBF3/3ARf/9wEYf/cBGf/1gRp/9YEa//WBG3/1gRv/9YEcf/WBHP/1gR1/9wEd//cBHn/3AR7/9YEff/cBH//3QSB/90Eg//dBIX/3QSH/90Eif/dBIv/3QSN/+EEj//hBJH/4QSY/+EEtP/hBLj/3AS8/9YEwP/dBMX/3ATH/9wE0f/hBNP/4QTf/+EE4f/hAL8ABgAMAAsADABH/+gASP/oAEn/6ABKAAwAS//oAFP/6gBV/+gAWgALAF0ACwCU/+gAmf/oALv/6AC9AAsAvv/0AMT/1wDGAAsAyP/oAMn/6ADKAAwA9//oAQP/6AEY/+oBGgALAR7/6AEi/+gBQv/oAWD/6AFh/+gBa//oAYUADAGGAAwBiAAMAYkADAGKAAwB7gANAfEADQHzAA4B9P/1Afb/7AH4/+0CAP/sAgb/vwIH/+0CCP+/Ag8ADgIQ/+0CEwAOAisADgIs/+0CLQANAi8ADgI1/+0CTP/uAk7/vwK9/+gCvv/oAr//6ALA/+gCwf/oAsf/6gLI/+oCyf/qAsr/6gLL/+oC0AALAtEACwLZ/+gC2//oAt3/6ALf/+gC4f/oAuP/6ALl/+gC5//oAun/6ALr/+gC7f/oAu//6ALx/+gC8//oAxX/6gMX/+oDGf/qAz8ACwNO/78DT/+/A1D/vwNR/78DUv+/A1P/vwNU/78DVf/tA1//7QNg/+0DYf/tA2L/7QNj/+0DaAANA2n/vwNq/78Da/+/A2z/7QNt/+0Dbv/tA2//7QN2/+0Dd//tA3j/7QN5/+0Dif/tA4r/7QOL/+0Dj//1A5D/9QOR//UDkv/1A5QADgOdAA0DngANA7r/6APA/+oDwgALA8b/6gPg/+gD4v/qA+T/6APlAAsD5//oA+4ACwP2AAsD9wAMA/gADAP7AAwEAv/oBAcACwQI/+gEDf/oBA8ACwQb/+gEHf/oBB7/6AQo/+oEKv/oBCz/6gQwAAsEMgALBDQACwQ5/+gEU//oBFX/6ARX/+gEWf/oBFv/6ARd/+gEX//oBGH/6ARn/+oEaf/qBGv/6gRt/+oEb//qBHH/6gRz/+oEdf/oBHf/6AR5/+gEe//qBH3/6ASNAAsEjwALBJEACwS4/+gEvP/qBMX/6ATH/+gE3wALBOEACwTn/78E6//tBOwADQTu/78E+gANBP0ADQUG/78FDf/tBRD/7QURAA4FFf/tBRYADQDjAAYADQALAA0ARf/wAEf/tgBI/7YASf+2AEoADQBL/7YAU//aAFX/tgBaAAsAXQALAJT/tgCZ/7YAu/+2AL0ACwC+/80Ax/+7AMj/wADJ/7YAzP/VAO3/tQDy/74A9/+2AQP/tgEE/74BGP/aARoACwEc/+YBHv+2ASAADAEi/7YBQv+2AVH/vgFg/7YBYf+2AWMACwFlAAsBa/+2AXD/vgGFAA0BhgANAYgADQGJAA0BigANAe4ADQHxAA0B8wAOAfT/9QH2/+wB+P/tAgD/7AIG/78CB//tAgj/vwIPAA4CEP/tAhMADgIrAA4CLP/tAi0ADQIvAA4CNf/tAkz/7gJO/78Ctv/wArf/8AK4//ACuf/wArr/8AK7//ACvP/wAr3/tgK+/7YCv/+2AsD/tgLB/7YCx//aAsj/2gLJ/9oCyv/aAsv/2gLQAAsC0QALAtP/8ALV//AC1//wAtn/tgLb/7YC3f+2At//tgLh/7YC4/+2AuX/tgLn/7YC6f+2Auv/tgLt/7YC7/+2AvH/tgLz/7YDFf/aAxf/2gMZ/9oDPwALA07/vwNP/78DUP+/A1H/vwNS/78DU/+/A1T/vwNV/+0DX//tA2D/7QNh/+0DYv/tA2P/7QNoAA0Daf+/A2r/vwNr/78DbP/tA23/7QNu/+0Db//tA3b/7QN3/+0DeP/tA3n/7QOJ/+0Div/tA4v/7QOP//UDkP/1A5H/9QOS//UDlAAOA50ADQOeAA0Duv+2A8D/2gPCAAsDxv/aA9//8APg/7YD4v/aA+T/tgPlAAsD5/+2A+4ACwP2AAsD9wANA/gADQP7AA0D///wBAL/tgQHAAsECP+2BA3/tgQPAAsEFf/wBBf/8AQb/7YEHf+2BB7/tgQo/9oEKv+2BCz/2gQwAAsEMgALBDQACwQ5/7YEO//wBD3/8AQ///AEQf/wBEP/8ARF//AER//wBEn/8ARL//AETf/wBE//8ARR//AEU/+2BFX/tgRX/7YEWf+2BFv/tgRd/7YEX/+2BGH/tgRn/9oEaf/aBGv/2gRt/9oEb//aBHH/2gRz/9oEdf+2BHf/tgR5/7YEe//aBH3/tgSNAAsEjwALBJEACwS2//AEuP+2BLz/2gTF/7YEx/+2BN8ACwThAAsE5/+/BOv/7QTsAA0E7v+/BPoADQT9AA0FBv+/BQ3/7QUQ/+0FEQAOBRX/7QUWAA0A5wAQ/wcAEv8HACX/TgAu/w0AOAAUAEX/3gBH/+sASP/rAEn/6wBL/+sAU//rAFX/6wBW/+YAWf/qAFr/6ABd/+gAlP/rAJn/6wCb/+oAsv9OALT/TgC7/+sAvf/oAMj/6wDJ/+sAy//qANIAFADWABQA9//rAQP/6wEN/04BGP/rARr/6AEe/+sBIv/rATkAFAFC/+sBRQAUAWD/6wFh/+sBa//rAYf/BwGL/wcBj/8HAZD/BwIG/8ACCP/AAk7/wAKb/04CnP9OAp3/TgKe/04Cn/9OAqD/TgKh/04Ctv/eArf/3gK4/94Cuf/eArr/3gK7/94CvP/eAr3/6wK+/+sCv//rAsD/6wLB/+sCx//rAsj/6wLJ/+sCyv/rAsv/6wLM/+oCzf/qAs7/6gLP/+oC0P/oAtH/6ALS/04C0//eAtT/TgLV/94C1v9OAtf/3gLZ/+sC2//rAt3/6wLf/+sC4f/rAuP/6wLl/+sC5//rAun/6wLr/+sC7f/rAu//6wLx/+sC8//rAwH/DQMV/+sDF//rAxn/6wMqABQDLAAUAy4AFAMx/+oDM//qAzX/6gM3/+oDOf/qAzv/6gM//+gDTv/AA0//wANQ/8ADUf/AA1L/wANT/8ADVP/AA2n/wANq/8ADa//AA6L/TgOq/04Duv/rA77/6gPA/+sDwv/oA8X/6gPG/+sDx//qA87/DQPS/04D3QAUA9//3gPg/+sD4v/rA+T/6wPl/+gD5//rA+7/6AP2/+gD/v9OA///3gQC/+sEB//oBAj/6wQN/+sED//oBBT/TgQV/94EFv9OBBf/3gQb/+sEHf/rBB7/6wQo/+sEKv/rBCz/6wQw/+gEMv/oBDT/6AQ5/+sEOv9OBDv/3gQ8/04EPf/eBD7/TgQ//94EQP9OBEH/3gRC/04EQ//eBET/TgRF/94ERv9OBEf/3gRI/04ESf/eBEr/TgRL/94ETP9OBE3/3gRO/04ET//eBFD/TgRR/94EU//rBFX/6wRX/+sEWf/rBFv/6wRd/+sEX//rBGH/6wRn/+sEaf/rBGv/6wRt/+sEb//rBHH/6wRz/+sEdf/rBHf/6wR5/+sEe//rBH3/6wR//+oEgf/qBIP/6gSF/+oEh//qBIn/6gSL/+oEjf/oBI//6ASR/+gEkwAUBLX/TgS2/94EuP/rBLz/6wTA/+oExf/rBMf/6wTbABQE3//oBOH/6ATn/8AE7v/ABQb/wAACAJ8ABAAEAAAABgAGAAEACwAMAAIAJQAqAAQALAAtAAoALwA2AAwAOAA4ABQAOgA/ABUARQBGABsASQBKAB0ATABMAB8ATwBPACAAUQBUACEAVgBWACUAWABYACYAWgBdACcAXwBfACsAigCKACwAlgCWAC0AnQCdAC4AsQC1AC8AtwC5ADQAuwC7ADcAvQC+ADgAwADBADoAwwDFADwAxwDOAD8A0gDSAEcA1ADeAEgA4ADvAFMA8QDxAGMA9gD4AGQA+wD8AGcA/gEAAGkBAwEFAGwBCgEKAG8BDQENAHABGAEaAHEBIgEiAHQBLgEwAHUBMwE1AHgBNwE3AHsBOQE5AHwBOwE7AH0BQwFEAH4BVAFUAIABVgFWAIEBWAFYAIIBXAFeAIMBhQGGAIYBiAGKAIgB8wHzAIsB9QH2AIwB+AH4AI4B+wH7AI8CBgIIAJACSwJLAJMCTgJOAJQCYAJgAJUCYgJjAJYClgKXAJgCmQKZAJoCmwKwAJsCtQK8ALECvgLBALkCxgLLAL0C0ALYAMMC2gLaAMwC3ALcAM0C3gLeAM4C4ALgAM8C4gLrANAC9AL2ANoC+AL4AN0C+gL6AN4C/AL8AN8C/gL+AOADAwMDAOEDBQMFAOIDBwMHAOMDCQMJAOQDCwMLAOUDDQMZAOYDGwMbAPMDHQMdAPQDHwMfAPUDKgMqAPYDLAMsAPcDLgMuAPgDPAM8APkDPgNBAPoDQwNDAP4DRQNFAP8DSwNUAQADXwNjAQoDaQNrAQ8DcANwARIDggOFARMDiQOLARcDlAOUARoDogOnARsDqgO5ASEDvAO8ATEDwAPAATIDwgPCATMDxgPGATQDyQPKATUDzAPNATcDzwPVATkD1wPZAUAD2wPgAUMD4gPjAUkD5QPoAUsD7gPvAU8D8QPxAVED8wPzAVID9QP4AVMD+wQAAVcEAgQCAV0EBgQHAV4EDAQMAWAEDgQXAWEEGgQbAWsEHQQgAW0EJwQoAXEELAQsAXMELgQ0AXQEOgRiAXsEZARkAaQEZgRzAaUEewR7AbMEjASRAbQEkwSTAboElwSYAbsEmwSbAb0EnQSeAb4EoASgAcAEogSiAcEEswS3AcIEuQS5AccEuwS8AcgEvgS+AcoEwgTEAcsExgTGAc4EyATKAc8EzATMAdIEzgTOAdME0ATWAdQE2ATYAdsE2wTbAdwE3gTiAd0E5ATkAeIE5gTnAeME6wTrAeUE7gTuAeYE+QT5AecFBgUGAegFDQUNAekFEQURAeoAAgCaAAYABgAAAAsACwABABAAEAACABIAEgADACUAKQAEACwANAAJADgAPgASAEUARwAZAEkASQAcAEwATAAdAFEAVAAeAFYAVgAiAFoAWgAjAFwAXgAkAIoAigAnAJYAlgAoALEAtAApAL0AvQAtAMEAwQAuAMcAxwAvANQA1QAwANcA1wAyANoA2gAzANwA3gA0AOAA5gA3AOwA7AA+AO4A7gA/APcA9wBAAPwA/ABBAP4A/wBCAQQBBQBEAQoBCgBGAQ0BDQBHARgBGgBIAS4BMABLATMBNQBOATcBNwBRATkBOQBSATsBOwBTAUMBRABUAVQBVABWAVYBVgBXAVgBWABYAVwBXgBZAYUBiwBcAY8BkABjAfMB8wBlAfgB+ABmAfsB/ABnAgYCCABpAhoCGgBsAikCKwBtAksCSwBwAk4CTgBxAmACYAByAmICYwBzApYClwB1ApkCmQB3ApsCwQB4AsYCywCfAtAC4AClAuIC6wC2AvQC9gDAAvgC+ADDAvoC+gDEAvwC/ADFAv4C/gDGAwEDAQDHAwMDAwDIAwUDBQDJAwcDBwDKAwkDCQDLAwsDCwDMAw0DGQDNAxsDGwDaAx0DHQDbAx8DHwDcAyoDKgDdAywDLADeAy4DLgDfAzADMADgAzIDMgDhAzQDNADiAzYDNgDjAzgDOADkAzoDOgDlAzwDPADmAz4DRgDnA0sDVADwA18DYwD6A2kDawD/A3ADcAECA4EDhQEDA4kDiwEIA5QDlAELA6IDpwEMA6oDuQESA7wDvAEiA8ADwAEjA8IDwgEkA8YDxgElA8kDygEmA8wD1QEoA9cD2QEyA9sD4AE1A+ID6AE7A+4D7wFCA/ED8QFEA/MD8wFFA/UD+AFGA/sEAAFKBAIEAgFQBAYEBwFRBAwEFwFTBBoEGwFfBB0EIAFhBCcEKAFlBCwELAFnBC4ENAFoBDoEYgFvBGQEZAGYBGYEcwGZBHsEewGnBH4EfgGoBIAEgAGpBIwEkQGqBJMEkwGwBJcEmAGxBJsEmwGzBJ0EngG0BKAEoAG2BKIEogG3BLMEtwG4BLkEuQG9BLsEvAG+BL4EvgHABMIExAHBBMYExgHEBMgEygHFBMwEzAHIBM4EzgHJBNAE1gHKBNgE2AHRBNsE2wHSBN0E4gHTBOQE5wHZBOsE6wHdBO4E7gHeBPQE9AHfBPkE+QHgBQQFBAHhBQYFBgHiBQ0FDQHjBREFEQHkAAIBdAAGAAYAEgALAAsAEgAQABAAGgASABIAGgAlACUAAgAmACYAJAAnACcADwAoACgAAQApACkABAAuAC4ACAAvAC8ADQAwADAAFwAzADMAAQA0ADQAJQA4ADgAEQA5ADkACAA6ADoAHAA7ADsAGAA8ADwAEAA9AD0ADAA+AD4AGQBFAEUAAwBGAEYADgBHAEcAEwBJAEkABQBMAEwACQBRAFIACQBTAFMABgBUAFQADgBWAFYAGwBaAFoABwBcAFwAFQBdAF0ABwBeAF4AHwCKAIoADgCWAJYAAQCxALEAFgCyALIAKACzALMAAQC0ALQAAgC9AL0ABwDBAMEACQDHAMcADgDUANUAIADaANoAEADeAN4AIQDkAOQAIADmAOYAIADsAOwAIgDuAO4AFQD3APcADgD8APwAIwD+AP4AIwD/AP8ADgEEAQUAIwEKAQoAIwENAQ0AAgEYARgABgEZARkAHAEaARoABwEuAS4ADgEvAS8AFgEwATAAIgEzATMAEAE0ATQAFQE1ATUADQE3ATcADQE5ATkADQFDAUMAEAFEAUQAFQFYAVgAAQFcAVwAIgFdAV0AEAFeAV4AFQGFAYYAEgGHAYcAGgGIAYoAEgGLAYsAGgGPAZAAGgHzAfMAHQH4AfgACgH7AfsAHgH8AfwAFAIGAgYAJgIHAgcACgIIAggACwIaAhoAFAIpAisAFAJLAksACgJOAk4ACwJgAmAADwJiAmMAAQKWApcAAQKZApkAEQKbAqEAAgKiAqIADwKjAqYABAKsArAAAQKxArQACAK1ArUADAK2ArwAAwK9Ar0AEwK+AsEABQLGAsYACQLHAssABgLQAtEABwLSAtIAAgLTAtMAAwLUAtQAAgLVAtUAAwLWAtYAAgLXAtcAAwLYAtgADwLZAtkAEwLaAtoADwLbAtsAEwLcAtwADwLdAt0AEwLeAt4ADwLfAt8AEwLgAuAAAQLiAuIABALjAuMABQLkAuQABALlAuUABQLmAuYABALnAucABQLoAugABALpAukABQLqAuoABALrAusABQL1AvUACQMBAwEACAMDAwMADQMFAwUAFwMHAwcAFwMJAwkAFwMLAwsAFwMOAw4ACQMQAxAACQMSAxMACQMUAxQAAQMVAxUABgMWAxYAAQMXAxcABgMYAxgAAQMZAxkABgMbAxsAGwMdAx0AGwMfAx8AGwMqAyoAEQMsAywAEQMuAy4AEQMwAzAACAMyAzIACAM0AzQACAM2AzYACAM4AzgACAM6AzoACAM8AzwAGAM+Az4ADAM/Az8ABwNAA0AADANBA0EAGQNCA0IAHwNDA0MAGQNEA0QAHwNFA0UAGQNGA0YAHwNLA0wACgNNA00AHQNOA1QACwNfA2MACgNpA2sACwNwA3AACgOBA4EAFAOCA4UAHgOJA4sACgOUA5QAHQOiA6IAAgOjA6MABAOmA6YAAQOnA6cADAOqA6oAAgOrA6sAJAOsA6wABAOtA60AGQOwA7AADQOzA7MAAQO0A7QAJQO1A7UAEQO2A7YADAO3A7cAEAO5A7kADAO8A7wACQPAA8AABgPCA8IABwPGA8YABgPJA8kABAPKA8oAFgPOA84ACAPPA9AADQPRA9EAIQPSA9IAAgPTA9MAJAPUA9QAFgPVA9UABAPZA9kAAQPbA9sAJQPcA9wADwPdA90AEQPeA94AEAPfA98AAwPgA+AABQPiA+IABgPjA+MADgPkA+QAEwPlA+UABwPmA+YAFQPnA+cABQPoA+gAIgPuA+4ABwPvA+8AGAPxA/EAGAPzA/MAGAP1A/UADAP2A/YABwP3A/gAEgP7A/sAJwP9A/0ACQP+A/4AAgP/A/8AAwQABAAABAQCBAIABQQGBAYAHAQHBAcABwQMBAwADwQNBA0AEwQOBA4ADAQPBA8ABwQRBBEAEAQSBBIAFQQUBBQAAgQVBBUAAwQWBBYAAgQXBBcAAwQaBBoABAQbBBsABQQdBB4ABQQfBB8AEAQgBCAAFQQnBCcAAQQoBCgABgQsBCwABgQuBC4ADgQvBC8AIQQwBDAABwQxBDEAIQQyBDIABwQzBDMAIQQ0BDQABwQ6BDoAAgQ7BDsAAwQ8BDwAAgQ9BD0AAwQ+BD4AAgQ/BD8AAwRABEAAAgRBBEEAAwRCBEIAAgRDBEMAAwREBEQAAgRFBEUAAwRGBEYAAgRHBEcAAwRIBEgAAgRJBEkAAwRKBEoAAgRLBEsAAwRMBEwAAgRNBE0AAwROBE4AAgRPBE8AAwRQBFAAAgRRBFEAAwRSBFIABARTBFMABQRUBFQABARVBFUABQRWBFYABARXBFcABQRYBFgABARZBFkABQRaBFoABARbBFsABQRcBFwABARdBF0ABQReBF4ABARfBF8ABQRgBGAABARhBGEABQRmBGYAAQRnBGcABgRoBGgAAQRpBGkABgRqBGoAAQRrBGsABgRsBGwAAQRtBG0ABgRuBG4AAQRvBG8ABgRwBHAAAQRxBHEABgRyBHIAAQRzBHMABgR7BHsABgR+BH4ACASABIAACASMBIwADASNBI0ABwSOBI4ADASPBI8ABwSQBJAADASRBJEABwSTBJMAEQSXBJcAFgSYBJgAIgSbBJsACQSdBJ0AIASeBJ4AFgSgBKAADQSiBKIADAS0BLQACQS1BLUAAgS2BLYAAwS3BLcABAS7BLsAAQS8BLwABgS+BL4AGwTCBMIAJATDBMMADgTEBMQAAQTGBMYAAQTJBMkACQTKBMoADQTMBMwADQTOBM4AFwTRBNEACQTTBNMACQTUBNQAAQTVBNUAJQTWBNYADgTYBNgAGwTbBNsAEQTdBN0ACATeBN4AHATfBN8ABwTgBOAAHAThBOEABwTiBOIAGATkBOQAGQTlBOUAHwTmBOYAAQTnBOcACwTrBOsACgTuBO4ACwT0BPQAFAT5BPkAHQUEBQQAFAUGBQYACwUNBQ0ACgURBREAHQABAAYFEQASAAAAAAAAAAAAEgAAAAAAAAAAABgAGwAYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAACAAAAAAAAAAIAAAAAACMAAAAAAAAAAAACAAAAAgAAABQADQALABoAFgAPAAwAFwAAAAAAAAAAAAAAAAAGAAAAAQABAAEAAAABAAAAAAAAAAAAAAADAAMABwADAAEAAAAQAAAACAAJAAAAEwAJAB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAEAAAAAAAAAAgABAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACcAAgAEAAAAAAAAAAAAAAAAAAEAAAAJAAAAAAAAAAMAAAAAAAAAAAAAAAAAAQABAAAACAAAAAAAAAAAAAAAAAANAAIAHgAAAA0AAAAAAAAADwAAAAAAHgAfAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAABMAAAADAAMAIQADAAMAAwAAAAEAAwAiAAMAAwAAAAAAAwAAAAMAAAAAAAEAIQADAAAAAAACAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAACAAcAGgAJAAIAAAACAAEAAgAAAAIAAQAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAA8AEwAAAAMAAAAAAA0AAAAAAAMAAAADAAAAAAACAAEADwATAA0AAAAgACIAAAAAAAAAAAAAAAAAAAAeACEAAAADAAAAAwAAAAMAAAAAAAAAAAADAA8AEwAAAAEAAQAAAAAAAAAAAB4AAAAAAAAAAgABAAAAAAAAAB4AIQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGwAbAAAAEgASABgAEgASABIAGAAAAAAAAAAYABgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQAZACQAAAAOABUAHAAAAAUAAAAFAAAAAAAAAAAAAAAAAAAABQAAAAAAAAAAAAAAJQAFAAoAAAAAAAAAAAAAAAAAFQAFAAAAAAAVAAAAAAAAABkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAZAAAAAAAVAAUAEQAZABUAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgACAAAAAgACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABsAAAAAAAAAAAAAAAQABAAEAAQABAAEAAQAAgAAAAAAAAAAAAAAAAAAAAAAAAACAAIAAgACAAIACwALAAsACwAMAAYABgAGAAYABgAGAAYAAQABAAEAAQABAAAAAAAAAAAAAwAHAAcABwAHAAcACAAIAAgACAAJAAkABAAGAAQABgAEAAYAAgABAAIAAQACAAEAAgABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAIAAQACAAEAAgABAAIAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAMAAAADAAMAAgAHAAIABwACAAcAAAAAAAAAAAAAAAAAFAAQABQAEAAUABAAFAAQABQAEAANAAAADQAAAA0AAAALAAgACwAIAAsACAALAAgACwAIAAsACAAWAAAADAAJAAwAFwAdABcAHQAXAB0AAAAAAAIAAAAAAAAAAAAKAAoACgAKAAoACgAKAAUAAAAAAAAAAAAAAAAAAAAAAAAABQAFAAUABQAFAA4ADgAOAA4AEQAKAAoACgAFAAUABQAFAAAAAAAAAAAAAAAAAAUABQAFAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQAFAAUAAAAAAAAAHAAcABwAHAAAABUAAAAOAA4ADgAOAA4ADgAkABEAEQAAAAAAAAAEAAAAAAAAAAIADAAAAAAABAAAAAAAFwAAAAAAAAAAAAAAAgAAAAAADAAPAAAADAABAAAAAwAAAAgAAAAHAAAACQAAAAAACAAHAAgAAAAAAAAAAAAAAAAAIwAAAAAAHwAEAAAAAAAAAAAAAAAAAAIAAAAAAAIADQAPAAYAAQADAAcAAwABAAkAEwABAAMAEAAAAAAAAAADAAkAFgAAABYAAAAWAAAADAAJABIAEgAAAAAAJgAAAAMABAAGAAAAAAABAAMAAAAAABoACQABAAIAAAAAAAIAAQAMAAkAAAAPABMAAAAEAAYABAAGAAAAAAAAAAEAAAABAAEADwATAAAAAAAAAAMAAAADAAIABwACAAEAAgAHAAAAAAAfAAkAHwAJAB8ACQAgACIAAAADAAEABAAGAAQABgAEAAYABAAGAAQABgAEAAYABAAGAAQABgAEAAYABAAGAAQABgAEAAYAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAAAAAAAAAIABwACAAcAAgAHAAIABwACAAcAAgAHAAIABwACAAEAAgABAAIAAQACAAcAAgABAAsACAALAAgAAAAIAAAACAAAAAgAAAAIAAAACAAMAAkADAAJAAwACQAAAA0AAAAgACIAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAABsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMABAAGAAAAAQAAAAAAAgAHAAAAAAAAAAgAAAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAwACAAAAAAAAAAAAFAAQAA0AAAALABoACQAaAAkAFgAAABcAHQAAAAoAAAAAAAAABQARAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQAZAAAAEQAAAAAAAAAAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAFAAAAAAAFABUAGQAAAAAABQARAAH9qgAAAAH9qv6UAAH95wZ0AAH92gZ0AAH91QZbAAH9pwbDAAH+LwZPAAH95wUKAAH92gUKAAH91QToAAH9pwUDAAH+LwUNAAH95gSmAAH+TQSmAAH9+QUBAAH+HgUBAAECuv/2AAECeP/2AAEBSgAKAAEDjP5pAAEC3gAKAAECYAAKAAEBKgAKAAEDzAAAAAEDqP/8AAEBBAAKAAECvAAAAAECyAAKAAECJwAKAAECmf/2AAECSP/2AAECTv/2AAECWwAKAAEBEAAKAAECIP/2AAECo//2AAECXP/2AAEByQAKAAECWgAKAAEC3P/2AAECUAAAAAECcgAKAAEBDf41AAEBBf41AAECEQAIAAEBxgAKAAECfgAKAAECq/42AAECIf42AAECNQAKAAEC2f32AAEBIv5aAAECj/5IAAECJP40AAECYv4GAAEBBf4GAAECYgAKAAEC0/4CAAECOf4GAAECZP4GAAEA/f4HAAECgP48AAECHv4yAAECgP37AAECHv3yAAECbv4AAAEBuf38AAECbv5AAAEBuf48AAEBuQAAAAECDgAKAAECTf48AAEBxAAKAAECZf//AAECZf37AAEBAP5UAAECBv4DAAECBf4EAAECBQAIAAECbv39AAECDv4EAAECDgAIAAECMv48AAECHP4DAAECHP5DAAECQQAAAAECqQAKAAECbgAKAAECDf/2AAEA9gAKAAECUgAKAAEDS//2AAECgP//AAECAP/2AAECXQAKAAEC0AAKAAECHv/2AAEDjQAKAAEC9wAKAAEAvv41AAEDfgAKAAEDhAAKAAECq//6AAECIf/6AAECqAAAAAECPgAAAAECav/2AAECDv/3AAECtP6YAAEB5/6dAAECdf6eAAEBIv6aAAECxP6UAAECRP6QAAECrwAAAAECQ//2AAECr/6UAAECQ/6KAAECnf6UAAEB6P6UAAECwP/3AAECwP6LAAECOP6UAAECcP6mAAEC9/4PAAEC+P96AAECWQAAAAECbgAEAAEDuP/8AAECyQADAAECSQAKAAECcQASAAECiQANAAECBgAKAAECEwAKAAEC2f/6AAECKv5BAAEC0wAGAAECOQAKAAECtAADAAEB6AAIAAECdgAKAAECOQAAAAEBIgAGAAEBBQAKAAECRf/8AAECZAAKAAEA/QALAAECOAAAAAECXf6eAAECeP6KAAECNP6eAAECWf6UAAECNf4GAAECWf38AAEC0P6eAAECSf6eAAECjwBMAAECJAA4AAECjv7hAAECJP7NAAECYf6eAAEDfv6eAAEDhP6eAAEC0v6bAAECOf6eAAECEgAKAAEA8/5pAAECY/6eAAEA/f6fAAECgP6UAAECHv6KAAECbv6YAAEBuf6UAAECnQAAAAEClgAKAAECAAAKAAEClv6eAAECAP6eAAEDjf6eAAEC9v6eAAECbf6eAAECDv6eAAECxQAAAAECcwAKAAECHAAKAAECbgABAAECMgAAAAEBAAABAAEB0P/2AAECBgAHAAECVgAAAAECDwAKAAECJAAIAAEC/wAKAAEB4wAKAAECHAAHAAECJQAIAAECCf/2AAECZQAKAAECTf//AAEDwP/2AAEDaAAAAAECagAAAAECMv38AAEDAQAKAAECHwAWAAECtP5YAAEB6P5cAAECdv5eAAECOf5UAAECVv5UAAECJP5cAAEBBP6eAAEB3ga4AAECGQUKAAECywaKAAECGgUHAAECCAZHAAEC3gZIAAEBHwY9AAEBKgaaAAEDzAZCAAEDqAUKAAEBkwa4AAECqAZCAAECVwUBAAEDPwT9AAECvAZAAAED2AZIAAEC0wZIAAECkwZIAAEDgAZIAAECnwZWAAEDlAZAAAECigZMAAECIQT1AAECvQT1AAEDSAT9AAECSwT9AAECMwT8AAECgQT1AAEC9wT1AAECSwT1AAECTwT1AAEC6AbMAAECYQT1AAEDLAT1AAEDOgT9AAEDOwT1AAECDQT1AAECQwUJAAEDpwZDAAEDMQT9AAEB0wbMAAECfQYdAAECGQTvAAECRQVQAAEDNwZAAAECmQZhAAECSAUMAAEC0wdrAAECSwYhAAEC3AZXAAECTgUKAAECZgZMAAECiAYZAAECWwZMAAEBEAZMAAECxAZMAAECIAUKAAECYgZMAAECowZhAAEDAQUoAAECOQUoAAECXAUoAAECFQUoAAECTgUoAAEDJAUoAAECbwUoAAECNwUoAAECNQUoAAEDCAUoAAECLgUoAAEDBQUoAAECigUoAAEC3AUoAAECZgUoAAECQQUoAAECXwUoAAECcgZMAAEBDQToAAEBAQUoAAEDaAUKAAECDgUoAAECfgUoAAECqgeqAAECqQeSAAECqgfcAAEBIgexAAEBIgekAAEC1QeSAAECwgesAAECwQeTAAECngeqAAECngedAAECngdsAAECNQZ0AAECNAZbAAECNQalAAEBCwZrAAEBCwZdAAECPgZbAAECPwZbAAECOgZ0AAECOgZmAAECOgY1AAECqgdvAAECNQY4AAECrAe/AAECFgZ0AAECrAexAAECFgZmAAECrAeSAAECFgZHAAECrAeuAAECFgZjAAECMgehAAECdAd2AAECKgY4AAECdAeFAAECKQZIAAECdAehAAECKgZkAAECrgexAAECKwZmAAECrgebAAECKwZQAAECrQeSAAECKwZHAAECrgZVAAECKwUKAAECzgekAAECAgfFAAEBIQeZAAEBCgZSAAEBIgd2AAEBCwYvAAEBIgeOAAEBCwZHAAEBIQeFAAEDVwebAAEBDQZEAAEBFAenAAEBBQgDAAEC1geaAAECPwZjAAECwgdwAAECPwY4AAECwgeIAAECPwZQAAECwgePAAECPwZYAAECWweqAAEBmgZ0AAECWweaAAEBmgZjAAECfQesAAECHgZ0AAECfQeeAAECHgZmAAECfQebAAECHgZjAAECbQeZAAECnQeSAAECOgZbAAECngdvAAECOgY4AAECngeHAAECOgZQAAECngfcAAECOgalAAECngeOAAECOgZYAAEDkQedAAEC9AZmAAECdAecAAECAwZmAAECbweqAAECBwZ0AAECbwd+AAECBgZHAAECbweaAAECBwZjAAEDqQe2AAEDXQZ1AAECywf0AAECGgZxAAEBxAUoAAECTgZ5AAECTwZTAAECTwbDAAECIgaSAAECIgaEAAEA/waSAAEA/waEAAECbwZ5AAECXQaEAAECXAZ5AAECXQZTAAECQgaSAAECQgaEAAECQgZTAAECTwZWAAECTwZuAAECTwaSAAECTwaEAAECTwZlAAECTwaBAAEBxAaBAAECIgZWAAECIgZuAAECIgZlAAECIgaBAAECVwaEAAECVwZuAAECVgZlAAECVwUoAAECZQaEAAEA/gZ5AAEA/wZWAAEA/wZuAAEA/gZlAAEC4gaEAAEA9QaSAAEA9QUoAAECcAaSAAECcAaBAAECXQZWAAECXQZuAAECXQZ2AAECAgaBAAECLwaSAAECLwaEAAECLwaBAAECQgZ5AAECQgZWAAECQgZuAAECQgbDAAECQgZ2AAECQgUoAAEDAQaEAAECGQaEAAECHAaSAAECHAZlAAECHAaBAAECdAdrAAECbgUKAAECQgUKAAEBJgT1AAECUgUKAAEBJgYgAAECKwYoAAECKwT9AAEDTAT7AAECdAdzAAECawexAAEBIgdzAAEDVwY/AAECkweOAAEC0weOAAECSwZDAAECiAUAAAECKgY1AAEBrAZmAAEBCwYsAAEA3wZAAAECMwZmAAECAwZQAAEDkQeqAAEC9AZ0AAEDkQdsAAEC9AY1AAECdAeqAAECAwZ0AAEBDQZCAAEDeweqAAEDjAZ0AAECdAexAAEC0wexAAECKgZ0AAECSwZmAAEC3wT1AAECfQdeAAECGQYxAAECZgZVAAECDgUJAAECrAZVAAECFgUKAAED2AeOAAEDSAZDAAECqgdsAAECNQY1AAEDqQZMAAEDXQULAAECdAeOAAECKgZRAAECiAdEAAECKAULAAECKAY2AAED2AdzAAEDSAYoAAECZgeAAAECDgY0AAEC0wd2AAECSwYrAAEC0wdzAAECSwYoAAECwgdtAAECPwY1AAEC0gZEAAECMwULAAEC0gdwAAECMwY2AAECnweBAAECFgY1AAECkwd2AAECAwY4AAECkwdzAAECAwY1AAECkweVAAECAwZYAAEC1AdzAAECKQYoAAEDgAdzAAEDOgYoAAECqggBAAECNQbKAAECqgedAAECNQZmAAECqgeHAAECNQZQAAECdAgIAAECKgbKAAECdAeZAAECKQZcAAECdAekAAECKgZmAAEBIggIAAEBCwbBAAEBIgZIAAEBBgZAAAECwggCAAECPwbKAAECwgeeAAECPwZmAAECwQepAAECQwZ0AAECwQgAAAECQwbKAAECwQeRAAECQwZbAAECwQY/AAECQwUKAAECOgUKAAECnggBAAECOgbKAAECwge2AAECQgZfAAECwggMAAECQga1AAECwQedAAECQQZGAAECwgZMAAECQgT1AAECAwUKAAECdAgAAAECAwbKAAECcweRAAECAwZbAAEB/QT1AAEC1AZIAAECKQT9AAECawZIAAEBrAT9AAECdAZAAAEChwZMAAECBQUAAAECOgUJAAECdAZMAAECrge/AAECKwZ0AAEC1geqAAECPwZ0AAECqgeCAAECNQZMAAECdAeJAAECKgZMAAEBIgeJAAEBCwZDAAECwgeDAAECPwZMAAECWweCAAEBmgZMAAECngeCAAECOgZMAAECPgZMAAECWgZMAAECiwZHAAECMgZIAAECCAZIAAECzgZIAAECAgZpAAECWQemAAECXwexAAECWQY9AAECXwZHAAEBFAY9AAEBBQaaAAEDewZBAAEDjAUKAAEC1gZBAAECPwUKAAECWge2AAECiAZqAAECWwZBAAEBmgUKAAECfQZCAAECHgUKAAECbQZAAAEBRAXHAAECngZBAAEClgedAAECAQZRAAEClgZMAAECAgUAAAEDkQZBAAEC9AUKAAECbwZBAAECBwUKAAECwgZCAAECAgUoAAECcAUoAAECGQZTAAECIgZTAAECCwaSAAEA/wUoAAEA/wZTAAEC4gUoAAECAgaSAAECNwZuAAECCwUoAAECbwZuAAEC/wUoAAECXQUoAAECKwUoAAECHAUoAAECJQUoAAECDQUoAAECZQUoAAECGQUoAAECbwZWAAECNwZWAAEDaAZ0AAECXQaSAAECLwUoAAEDAQaSAAEDAQZTAAECGQaSAAECqgZBAAECNQUKAAECdAZIAAECKgUKAAECTwUoAAECIgUoAAEBCwUBAAAAAQAAAAoAZAAkAARERkxUAPhjeXJsAPhncmVrAPhsYXRuAPwAHwEQARgBIAEoATABOAE4AUABSAFQAVgBYAFoAXABeAGAAYgBkAGYAaABqAGwAbgBwAHIAdAB2AHQAdgB4AHoABpjMnNjAbBjY21wAjpkbGlnAbZkbm9tAbxmcmFjAkpsaWdhAcJsaWdhAkJsbnVtAchsb2NsAc5sb2NsAdRsb2NsAdpsb2NsAeBudW1yAeZvbnVtAexwbnVtAfJzbWNwAfhzczAxAf5zczAyAgRzczAzAgpzczA0AhBzczA1AhZzczA2AhxzczA3AiJzdWJzAihzdXBzAi50bnVtAjQBtgAAA7oAB0FaRSAD6kNSVCAD6kZSQSAEGk1PTCAETE5BViAEflJPTSAEsFRSSyAD6gABAAAAAQcCAAEAAAABBR4ABgAAAAECPgABAAAAAQIAAAQAAAABBJQAAQAAAAEBigABAAAAAQH6AAEAAAABAYAABAAAAAEBnAAEAAAAAQGcAAQAAAABAbAAAQAAAAEBZgABAAAAAQFkAAEAAAABAWIAAQAAAAEBfAABAAAAAQF+AAEAAAABAjYAAQAAAAEBhAABAAAAAQJEAAEAAAABAmoAAQAAAAECkAABAAAAAQK2AAEAAAABASAABgAAAAEBhAABAAAAAQGoAAEAAAABAboAAQAAAAEBzAABAAAAAQD+AAAAAQAAAAAAAQALAAAAAQAbAAAAAQAKAAAAAQAWAAAAAQAIAAAAAQAFAAAAAQAHAAAAAQAGAAAAAQAcAAAAAQATAAAAAQAUAAAAAQABAAAAAQAMAAAAAQANAAAAAQAOAAAAAQAPAAAAAQAQAAAAAQARAAAAAQASAAAAAQAeAAAAAQAdAAAAAQAVAAAAAgACAAQAAAACAAkACgAAAAMAFwAYABoAAP//ABQAAAABAAIAAwAEAAcADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZAAEHagACAAEHRgABAAEHRgH5AAEHRgGKAAEHRgIQAAEHRgGCAAEHbAGPAAEHTgABB0gAAQdGAAEHTAACB2AAAgJHAkgAAgdWAAICSQJKAAEHVAADBzYHOgc+AAIHUgADAokCigKKAAIHaAAGAnwCegJ9An4CewUpAAIHRgAGBSMFJAUlBSYFJwUoAAMAAQdUAAEHBgAAAAEAAAAZAAIHMgcaB5QHWAAHAAAHHgceBx4HHgceBx4AAgbaAAoB4gHhAeACOgI7AjwCPQI+Aj8CQAACBsAACgJZAHoAcwB0AloCWwJcAl0CXgJfAAIGpgAKAZYAegBzAHQBlwGYAZkBmgGbAZwAAgcAAAwCYAJiAmECYwJkAoICgwKEAoUChgKHAogAAgc2ABQCdQJ5AnMCcAJyAnECdgJ0AngCdwJqAmUCZgJnAmgCaQAaABwCbgKAAAIG0AAUBLACjASpBKoEqwSsBK0CgQSuBK8CZwJpAmgCZgJqAoAAGgJuABwCZQACBx4AFAJ2AngCeQJzAnACcgJxAnQCdwJ1ABsAFQAWABcAGAAZABoAHAAdABQAAgbIABQErQSuAowEqQSqBKsErAKBBK8AFwAZABgAFgAbABQAGgAdABwAFQSwAAD//wAVAAAAAQACAAMABAAGAAcADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZAAD//wAVAAAAAQACAAMABAAFAAcADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZAAD//wAWAAAAAQACAAMABAAGAAcACAAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAAP//ABYAAAABAAIAAwAEAAYABwAJAAwADQAOAA8AEAARABIAEwAUABUAFgAXABgAGQAA//8AFgAAAAEAAgADAAQABgAHAAoADAANAA4ADwAQABEAEgATABQAFQAWABcAGAAZAAD//wAWAAAAAQACAAMABAAGAAcACwAMAA0ADgAPABAAEQASABMAFAAVABYAFwAYABkAAQeGADYHBAXGBcoGAgcSBggFzgcgBkQGTAYOBpgHZgXSBoQGVAYUB3YGGgZcBqQGIAcuBdYF2gYmBzwF3gXiBeYGZAZsBiwGsAdKBeoGjgZ0BjIHWAY4BnwGvAY+Be4F8gX2BfoGyAbUBuAG7Ab4Bf4AAgd+AOsCjQJOAk0CTAJLAkMCAQIAAf8B/gH9AfwB+wH6AfkB+AH3AfYB9QH0AfMB8gHxAfAB7wHuAe0CfwKPA0wCkQKQA0sB/gKOApMCbQTuBO8CBQIGBPAE8QTyAgcE8wIIAgkCCgT4AgsCCwT5BPoCDAINAg4CFQUHBQgCFgIXAhgCGQIaAhsFCwUMBQ4FEQUaAh0CHgIfAiACIQIiAiMCJAIlAiYCDwIQAhECEgITAhQCVgIoAikCKgIrBRQCLAIuAi8CMAIyAjQCkgNNA04DTwNQA1EDUgNTA1QDVQNWA1cDWANZA1oDWwNcA10DXgNfA2ADYQNiA2MDZANlA2YDZwNoA54DaQNqA2sDbANtA24DbwNwA3EDcgNzA3QDdQN2A3cDeAN5A3oDewN8A30DfgUbA4ADgQOCA4MDhAOFA4YDhwOIA4kDigOLA4wDjQOOA48DkAORBR4DkgOTA5UDlAOWA5cDmAOZA5oDmwOcA50DnwOgA6EFHAUdBOcE6ATpBOoE9AT3BPUE9gT7BPwE/QTrBOwE7QUGBQkFCgUNBQ8FEAIcBRIE/gT/BQAFAQUCBQMFBAUFBR8FIAUhBSIFEwUVBRYCMwUYAjUFGQUXAjECJwItBScFKAACB3wA+wICAo0B7AHrAeoB6QHoAecB5gHlAeQB4wJOAk0CTAJLAkMCAQIAAf8B/gH9AfwB+wH6AfkB+AH3AfYB9QH0AfMB8gHxAfAB7wHuAe0CAwIEAo8CkQKQApICjgKTAm0CBQIGAgcCCAIJAgoCCwIMAg0CDgIPAhACEQISAhMCFAIVAhYCFwIYAhkCGwIcBRoCHQIeAh8CIAIhAiICIwIkAiUCJgJWAigCKQIqAisFFAIsAi4CLwIwAjECMgIzAjQCfwI2AjcCOQI4A0sDTANNA04DTwNQA1EDUgNTA1QDVQNWA1cDWANZA1oDWwNcA10DXgNfA2ADYQNiA2MDZANlA2YDZwNoA2kDagNrA2wDbQNuA28DcANxA3IDcwN0A3UDdgN3A3gDeQN6A3sDfAN9A34DfwUbA4ADgQOCA4MDhAOFA4YDhwOIA4kDigOLA4wDjQOOA48DkAORBR4DkgOTA5UDlAOWA5cDmAOZA5oDmwOcA50DngOfA6ADoQUcBR0E5wToBOkE6gTrBOwE7QTuBO8E8ATxBPIE8wT0BPUE9gT3BPgE+QT6BPsE/AT9BP4E/wUABQEFAgUDAhoFBAUFBQYFBwUIBQkFCgULBQwFDQUOBQ8FEAURBRIFHwUgBSEFIgUTBRUFFgUYAjUFGQUXAicCLQUnBSgAAQABAXwAAQABAEsAAQABALsAAQABADYAAQABABMAAQACAyQDJQACB2AHVAABAAEASgACB1wHTgABB14AAQdgAAEHYgACAAEAFAAdAAAAAQACAC8ATwABAAMASgBXAJUAAQADAEkASwKFAAIAAAABBzoAAQAGAtYC1wLoAukDawN0AAEABgBNAE4C/QPqA+wEZQACAAMBlQGVAAAB4AHiAAECOgJAAAQAAgACAKgArAABASQBJwABAAEADAAnACgAKwAzADUARgBHAEgASwBTAFQAVQACAAIAFAAdAAACcAJ5AAoAAgAGAE0ATQABAE4ATgADAv0C/QACA+oD6gAEA+wD7AAFBGUEZQAGAAIABAAUAB0AAAKBAoEACgKMAowACwSpBLAADAACAAYAGgAaAAAAHAAcAAECZQJqAAICbgJuAAgCcAJ5AAkCgAKAABMAAQAUABoAHAJlAmYCZwJoAmkCagJuAoACgQKMBKkEqgSrBKwErQSuBK8EsAABBjoAAQY8AAEGPgABBkAAAQZCAAEGRAABBkYAAQZIAAEGSgABBkwAAQZOAAEGUAABBlIAAQZUAAEGVgACBlgGXgACBl4GZAACBmQGagACBmoGcAACBnAGdgACBnYGfAACBnwGggACBoIGiAACBogGjgACBo4GlAACBpQGmgADBpoGoAamAAMGpAaqBrAAAwauBrQGugADBrgGvgbEAAMGwgbIBs4AAwbMBtIG2AADBtYG3AbiAAMG4AbmBuwABAbqBvAG9gb8AAQG+Ab+BwQHCgAFBwYHDAcSBxgHHgAFBxgHHgckByoHMAAFByoHMAc2BzwHQgAFBzwHQgdIB04HVAAFB04HVAdaB2AHZgAFB2AHZgdsB3IHeAAFB3IHeAd+B4QHigAFB4QHigeQB5YHnAAFB5YHnAeiB6gHrgAGB6gHrge0B7oHwAfGAAYHvgfEB8oH0AfWB9wABgfUB9oH4AfmB+wH8gAGB+oH8Af2B/wIAggIAAYIAAgGCAwIEggYCB4ABggWCBwIIggoCC4INAAGCCwIMgg4CD4IRAhKAAcIighCCEgITghUCFoIYAAHCIIIVghcCGIIaAhuCHQAAgARACUAKQAAACsALQAFAC8ANAAIADYAOwAOAD0APgAUAEUASQAWAEsATQAbAE8AVAAeAFYAWwAkAF0AXgAqAIEAgQAsAIMAgwAtAIYAhgAuAIkAiQAvAI0AjQAwAJgAmwAxANAA0AA1AAEA6wAKAEUARgBHAEgASQBKAEsATABNAE4ATwBQAFEAUgBTAFQAVQBWAFcAWABZAFoAWwBcAF0AXgCFAIYAhwCJAIoAiwCNAJAAkgCUALsAvAC9AL4AvwDAAMEAwgDDAMQAxQDGAMcAyADJAMoAywDMAM0AzgDqAOsA7ADtAO4A7wDwAPEA8gDzAPQA9QD2APcA+AD5APoA+wD8AP0A/gD/AQABAQECAQMBBAEFAQYBBwEwATQBNgE4AToBPAFCAUQBRgFKAU0BWgKYApoCtgK3ArgCuQK6ArsCvAK9Ar4CvwLAAsECwgLDAsQCxQLGAscCyALJAsoCywLMAs0CzgLPAtAC0QLTAtUC1wLZAtsC3QLfAuEC4wLlAucC6QLrAu0C7wLxAvMC9QL3AvkC+wL9AwADAgMEAwYDCAMKAwwDDgMQAxIDFQMXAxkDGwMdAx8DIQMjAyUDJwMpAysDLQMvAzEDMwM1AzcDOQM7Az0DPwNCA0QDRgNIA0oDugO7A7wDvQO/A8ADwQPCA8MDxAPFA8YDxwPIA98D4APhA+ID4wPkA+UD5gPnA+gD6QPqA+sD7APtA+4D8APyA/QD9gQLBA0EDwQdBCQEKgQwBJoEmwSfBKMFJAUmAAEA+wAIAAoAFAAVABYAFwAYABkAGgAbABwAHQAlACYAJwAoACkAKgArACwALQAuAC8AMAAxADIAMwA0ADUANgA3ADgAOQA6ADsAPAA9AD4AZQBnAIEAgwCEAIwAjwCRAJMAsQCyALMAtAC1ALYAtwC4ALkAugDSANMA1ADVANYA1wDYANkA2gDbANwA3QDeAN8A4ADhAOIA4wDkAOUA5gDnAOgA6QEvATMBNQE3ATkBOwFBAUMBRQFJAUsBTAFYAVkBcQGyAbgBvQHAApYClwKZApsCnAKdAp4CnwKgAqECogKjAqQCpQKmAqcCqAKpAqoCqwKsAq0CrgKvArACsQKyArMCtAK1AtIC1ALWAtgC2gLcAt4C4ALiAuQC5gLoAuoC7ALuAvAC8gL0AvYC+AL6AvwC/gL/AwEDAwMFAwcDCQMLAw0DDwMRAxQDFgMYAxoDHAMeAyADIgMkAyYDKAMqAywDLgMwAzIDNAM2AzgDOgM8Az4DQANBA0MDRQNHA0kDogOjA6QDpQOmA6cDqAOqA6sDrAOtA64DrwOwA7EDsgOzA7QDtQO2A7cDuAO5A8kDygPLA8wDzQPOA88D0APRA9ID0wPUA9UD1gPXA9gD2QPaA9sD3APdA94D7wPxA/MD9QQKBAwEDgQjBCkELwSZBJ4EogUjBSUB1wACAE0B2AACAFAB2QADAEoATQHaAAMASgBQAdYAAgBKAdwAAgBYAdsAAgBYAAAAAQABAAEAAQAAAAMEwgACAK0C2AACAKkEyAACAK0E1QACAKkEwwACAK0C2QACAKkEsgACAKkEyQACAK0EZQACAK0E1gACAKkDRwACAKkDSQACAKkDSAACAKkDSgACAKkEwQACAKkExAACAK0ExgACAdUC8gACAdUEsQACAKkD/AACAKkE0AACAK0DKgACAdUE2wACAK0E3gACAKoE4AACAK0DQQACAKkE5AACAK0ExQACAK0ExwACAdUD/QACAKkE0QACAK0DKwACAdUE3AACAK0E3wACAKoE4QACAK0DQgACAKkE5QACAK0DAwACAdUEygACAKkEzAACAK0DBQACAKkDBwACAdUEzgACAK0DIAACAKkDJgACAdUE2QACAK0D7wACAKgD8QACAKkE4gACAK0DBAACAdUEywACAKkEzQACAK0DBgACAKkDCAACAdUEzwACAK0DIQACAKkDJwACAdUE2gACAK0D8AACAKgD8gACAKkE4wACAK0DGgACAKkDHAACAdUEvQACAKwE1wACAK0DGwACAKkDHQACAdUEvgACAKwE2AACAK0CqwACAKoDDQACAKkDDwACAdUEswACAKgE0gACAK0CtQACAKkD9QACAKgEjAACAK0EjgACAKsEkAACAKoCxgACAKoDDgACAKkDEAACAdUEtAACAKgE0wACAK0C0AACAKkD9gACAKgEjQACAK0EjwACAKsEkQACAKoCwgACAKgCwwACAKkC9wACAKoEYwACAKsEugACAKwEdAACAKkEdgACAKgEeAACAKsEegACAKoEfAACAK0EdQACAKkEdwACAKgEeQACAKsEewACAKoEfQACAK0EggACAKkEhAACAKgEhgACAKsEiAACAKoEigACAK0EgwACAKkEhQACAKgEhwACAKsEiQACAKoEiwACAK0CmwACAKgCnAACAKkCngACAKoEOgACAK0EPAACAKsEtQACAKwCowACAKgCpAACAKkEUgACAK0EVAACAKsEVgACAKoEtwACAKwCpwACAKgCqAACAKkC9gACAKoEYgACAKsEZAACAK0EuQACAKwCtgACAKgCtwACAKkCuQACAKoEOwACAK0EPQACAKsEtgACAKwCvgACAKgCvwACAKkEUwACAK0EVQACAKsEVwACAKoEuAACAKwCxwACAKgCyAACAKkCygACAKoEZwACAK0EaQACAKsEvAACAKwCzAACAKgCzQACAKkDMQACAKoEfwACAK0EgQACAKsEwAACAKwCrAACAKgCrQACAKkCrwACAKoEZgACAK0EaAACAKsEuwACAKwCsQACAKgCsgACAKkDMAACAKoEfgACAK0EgAACAKsEvwACAKwE1AADAKoAqQTdAAMAqgCp", + "Roboto-MediumItalic.ttf": "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", + "Roboto-Regular.ttf": "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" +}; var _global = typeof window === 'object' ? window : typeof global === 'object' ? global : typeof self === 'object' ? self : this; if (typeof _global.pdfMake !== 'undefined' && typeof _global.pdfMake.addVirtualFileSystem !== 'undefined') { _global.pdfMake.addVirtualFileSystem(vfs); } if (typeof module !== 'undefined') { module.exports = vfs; } \ No newline at end of file diff --git a/eslint.config.js b/eslint.config.js index ae47d95..a690580 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -6,6 +6,9 @@ export default [ globalIgnores([ '.wrangler/*', '_site/', - 'credentials/html-render-method-mustache/mustache.v4.2.0.js' + 'credentials/html-render-method-mustache/mustache.v4.2.0.js', + 'credentials/html-render-method-pdfmake/mustache.v4.2.0.js', + 'credentials/html-render-method-pdfmake/pdfmake.v0.3.8.js', + 'credentials/html-render-method-pdfmake/vfs_fonts.v0.3.8.js' ]) ];