@vitaeflow/sdk-js
Version:
Official JavaScript/TypeScript SDK for VitaeFlow - Embed and extract structured resume data from PDFs
1,505 lines (1,495 loc) • 1.68 MB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/tslib/tslib.es6.js
var tslib_es6_exports = {};
__export(tslib_es6_exports, {
__assign: () => __assign,
__asyncDelegator: () => __asyncDelegator,
__asyncGenerator: () => __asyncGenerator,
__asyncValues: () => __asyncValues,
__await: () => __await,
__awaiter: () => __awaiter,
__classPrivateFieldGet: () => __classPrivateFieldGet,
__classPrivateFieldSet: () => __classPrivateFieldSet,
__createBinding: () => __createBinding,
__decorate: () => __decorate,
__exportStar: () => __exportStar,
__extends: () => __extends,
__generator: () => __generator,
__importDefault: () => __importDefault,
__importStar: () => __importStar,
__makeTemplateObject: () => __makeTemplateObject,
__metadata: () => __metadata,
__param: () => __param,
__read: () => __read,
__rest: () => __rest,
__spread: () => __spread,
__spreadArrays: () => __spreadArrays,
__values: () => __values
});
function __extends(d, b) {
extendStatics(d, b);
function __() {
this.constructor = d;
}
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
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 __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;
return g = { next: verb(0), "throw": verb(1), "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 (_) 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 };
}
}
function __createBinding(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
}
function __exportStar(m, exports2) {
for (var p in m) if (p !== "default" && !exports2.hasOwnProperty(p)) exports2[p] = 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 };
} finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
} finally {
if (e) throw e.error;
}
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
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 __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 = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
return this;
}, i;
function verb(n) {
if (g[n]) i[n] = function(v) {
return new Promise(function(a, b) {
q.push([n, v, a, b]) > 1 || resume(n, v);
});
};
}
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: n === "return" } : 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(v2) {
resolve({ value: v2, done: d });
}, reject);
}
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
} else {
cooked.raw = raw;
}
return cooked;
}
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
}
result.default = mod;
return result;
}
function __importDefault(mod) {
return mod && mod.__esModule ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
var extendStatics, __assign;
var init_tslib_es6 = __esm({
"node_modules/tslib/tslib.es6.js"() {
extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
d2.__proto__ = b2;
} || function(d2, b2) {
for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
};
return extendStatics(d, b);
};
__assign = function() {
__assign = Object.assign || function __assign2(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);
};
}
});
// node_modules/pdf-lib/cjs/utils/base64.js
var require_base64 = __commonJS({
"node_modules/pdf-lib/cjs/utils/base64.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.decodeFromBase64DataUri = exports2.decodeFromBase64 = exports2.encodeToBase64 = void 0;
var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
var lookup = new Uint8Array(256);
for (i = 0; i < chars.length; i++) {
lookup[chars.charCodeAt(i)] = i;
}
var i;
exports2.encodeToBase64 = function(bytes) {
var base64 = "";
var len = bytes.length;
for (var i2 = 0; i2 < len; i2 += 3) {
base64 += chars[bytes[i2] >> 2];
base64 += chars[(bytes[i2] & 3) << 4 | bytes[i2 + 1] >> 4];
base64 += chars[(bytes[i2 + 1] & 15) << 2 | bytes[i2 + 2] >> 6];
base64 += chars[bytes[i2 + 2] & 63];
}
if (len % 3 === 2) {
base64 = base64.substring(0, base64.length - 1) + "=";
} else if (len % 3 === 1) {
base64 = base64.substring(0, base64.length - 2) + "==";
}
return base64;
};
exports2.decodeFromBase64 = function(base64) {
var bufferLength = base64.length * 0.75;
var len = base64.length;
var i2;
var p = 0;
var encoded1;
var encoded2;
var encoded3;
var encoded4;
if (base64[base64.length - 1] === "=") {
bufferLength--;
if (base64[base64.length - 2] === "=") {
bufferLength--;
}
}
var bytes = new Uint8Array(bufferLength);
for (i2 = 0; i2 < len; i2 += 4) {
encoded1 = lookup[base64.charCodeAt(i2)];
encoded2 = lookup[base64.charCodeAt(i2 + 1)];
encoded3 = lookup[base64.charCodeAt(i2 + 2)];
encoded4 = lookup[base64.charCodeAt(i2 + 3)];
bytes[p++] = encoded1 << 2 | encoded2 >> 4;
bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
}
return bytes;
};
var DATA_URI_PREFIX_REGEX = /^(data)?:?([\w\/\+]+)?;?(charset=[\w-]+|base64)?.*,/i;
exports2.decodeFromBase64DataUri = function(dataUri) {
var trimmedUri = dataUri.trim();
var prefix = trimmedUri.substring(0, 100);
var res = prefix.match(DATA_URI_PREFIX_REGEX);
if (!res)
return exports2.decodeFromBase64(trimmedUri);
var fullMatch = res[0];
var data = trimmedUri.substring(fullMatch.length);
return exports2.decodeFromBase64(data);
};
}
});
// node_modules/pdf-lib/cjs/utils/strings.js
var require_strings = __commonJS({
"node_modules/pdf-lib/cjs/utils/strings.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.findLastMatch = exports2.parseDate = exports2.breakTextIntoLines = exports2.charSplit = exports2.charAtIndex = exports2.mergeLines = exports2.lineSplit = exports2.isNewlineChar = exports2.newlineChars = exports2.escapedNewlineChars = exports2.cleanText = exports2.escapeRegExp = exports2.addRandomSuffix = exports2.copyStringIntoBuffer = exports2.padStart = exports2.charFromHexCode = exports2.charFromCode = exports2.toHexString = exports2.toHexStringOfMinLength = exports2.toCodePoint = exports2.toCharCode = void 0;
exports2.toCharCode = function(character) {
return character.charCodeAt(0);
};
exports2.toCodePoint = function(character) {
return character.codePointAt(0);
};
exports2.toHexStringOfMinLength = function(num, minLength) {
return exports2.padStart(num.toString(16), minLength, "0").toUpperCase();
};
exports2.toHexString = function(num) {
return exports2.toHexStringOfMinLength(num, 2);
};
exports2.charFromCode = function(code) {
return String.fromCharCode(code);
};
exports2.charFromHexCode = function(hex) {
return exports2.charFromCode(parseInt(hex, 16));
};
exports2.padStart = function(value, length, padChar) {
var padding = "";
for (var idx = 0, len = length - value.length; idx < len; idx++) {
padding += padChar;
}
return padding + value;
};
exports2.copyStringIntoBuffer = function(str, buffer, offset) {
var length = str.length;
for (var idx = 0; idx < length; idx++) {
buffer[offset++] = str.charCodeAt(idx);
}
return length;
};
exports2.addRandomSuffix = function(prefix, suffixLength) {
if (suffixLength === void 0) {
suffixLength = 4;
}
return prefix + "-" + Math.floor(Math.random() * Math.pow(10, suffixLength));
};
exports2.escapeRegExp = function(str) {
return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
};
exports2.cleanText = function(text) {
return text.replace(/\t|\u0085|\u2028|\u2029/g, " ").replace(/[\b\v]/g, "");
};
exports2.escapedNewlineChars = ["\\n", "\\f", "\\r", "\\u000B"];
exports2.newlineChars = ["\n", "\f", "\r", "\v"];
exports2.isNewlineChar = function(text) {
return /^[\n\f\r\u000B]$/.test(text);
};
exports2.lineSplit = function(text) {
return text.split(/[\n\f\r\u000B]/);
};
exports2.mergeLines = function(text) {
return text.replace(/[\n\f\r\u000B]/g, " ");
};
exports2.charAtIndex = function(text, index) {
var cuFirst = text.charCodeAt(index);
var cuSecond;
var nextIndex = index + 1;
var length = 1;
if (
// Check if it's the start of a surrogate pair.
cuFirst >= 55296 && cuFirst <= 56319 && // high surrogate
text.length > nextIndex
) {
cuSecond = text.charCodeAt(nextIndex);
if (cuSecond >= 56320 && cuSecond <= 57343)
length = 2;
}
return [text.slice(index, index + length), length];
};
exports2.charSplit = function(text) {
var chars = [];
for (var idx = 0, len = text.length; idx < len; ) {
var _a = exports2.charAtIndex(text, idx), c = _a[0], cLen = _a[1];
chars.push(c);
idx += cLen;
}
return chars;
};
var buildWordBreakRegex = function(wordBreaks) {
var newlineCharUnion = exports2.escapedNewlineChars.join("|");
var escapedRules = ["$"];
for (var idx = 0, len = wordBreaks.length; idx < len; idx++) {
var wordBreak = wordBreaks[idx];
if (exports2.isNewlineChar(wordBreak)) {
throw new TypeError("`wordBreak` must not include " + newlineCharUnion);
}
escapedRules.push(wordBreak === "" ? "." : exports2.escapeRegExp(wordBreak));
}
var breakRules = escapedRules.join("|");
return new RegExp("(" + newlineCharUnion + ")|((.*?)(" + breakRules + "))", "gm");
};
exports2.breakTextIntoLines = function(text, wordBreaks, maxWidth, computeWidthOfText) {
var regex = buildWordBreakRegex(wordBreaks);
var words = exports2.cleanText(text).match(regex);
var currLine = "";
var currWidth = 0;
var lines = [];
var pushCurrLine = function() {
if (currLine !== "")
lines.push(currLine);
currLine = "";
currWidth = 0;
};
for (var idx = 0, len = words.length; idx < len; idx++) {
var word = words[idx];
if (exports2.isNewlineChar(word)) {
pushCurrLine();
} else {
var width = computeWidthOfText(word);
if (currWidth + width > maxWidth)
pushCurrLine();
currLine += word;
currWidth += width;
}
}
pushCurrLine();
return lines;
};
var dateRegex = /^D:(\d\d\d\d)(\d\d)?(\d\d)?(\d\d)?(\d\d)?(\d\d)?([+\-Z])?(\d\d)?'?(\d\d)?'?$/;
exports2.parseDate = function(dateStr) {
var match = dateStr.match(dateRegex);
if (!match)
return void 0;
var year = match[1], _a = match[2], month = _a === void 0 ? "01" : _a, _b = match[3], day = _b === void 0 ? "01" : _b, _c = match[4], hours = _c === void 0 ? "00" : _c, _d = match[5], mins = _d === void 0 ? "00" : _d, _e = match[6], secs = _e === void 0 ? "00" : _e, _f = match[7], offsetSign = _f === void 0 ? "Z" : _f, _g = match[8], offsetHours = _g === void 0 ? "00" : _g, _h = match[9], offsetMins = _h === void 0 ? "00" : _h;
var tzOffset = offsetSign === "Z" ? "Z" : "" + offsetSign + offsetHours + ":" + offsetMins;
var date = /* @__PURE__ */ new Date(year + "-" + month + "-" + day + "T" + hours + ":" + mins + ":" + secs + tzOffset);
return date;
};
exports2.findLastMatch = function(value, regex) {
var _a;
var position = 0;
var lastMatch;
while (position < value.length) {
var match = value.substring(position).match(regex);
if (!match)
return { match: lastMatch, pos: position };
lastMatch = match;
position += ((_a = match.index) !== null && _a !== void 0 ? _a : 0) + match[0].length;
}
return { match: lastMatch, pos: position };
};
}
});
// node_modules/pdf-lib/cjs/utils/arrays.js
var require_arrays = __commonJS({
"node_modules/pdf-lib/cjs/utils/arrays.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.toUint8Array = exports2.canBeConvertedToUint8Array = exports2.pluckIndices = exports2.range = exports2.sum = exports2.reverseArray = exports2.sortedUniq = exports2.byAscendingId = exports2.arrayAsString = exports2.mergeUint8Arrays = exports2.mergeIntoTypedArray = exports2.typedArrayFor = exports2.last = void 0;
var base64_1 = require_base64();
var strings_1 = require_strings();
exports2.last = function(array) {
return array[array.length - 1];
};
exports2.typedArrayFor = function(value) {
if (value instanceof Uint8Array)
return value;
var length = value.length;
var typedArray = new Uint8Array(length);
for (var idx = 0; idx < length; idx++) {
typedArray[idx] = value.charCodeAt(idx);
}
return typedArray;
};
exports2.mergeIntoTypedArray = function() {
var arrays = [];
for (var _i = 0; _i < arguments.length; _i++) {
arrays[_i] = arguments[_i];
}
var arrayCount = arrays.length;
var typedArrays = [];
for (var idx = 0; idx < arrayCount; idx++) {
var element = arrays[idx];
typedArrays[idx] = element instanceof Uint8Array ? element : exports2.typedArrayFor(element);
}
var totalSize = 0;
for (var idx = 0; idx < arrayCount; idx++) {
totalSize += arrays[idx].length;
}
var merged = new Uint8Array(totalSize);
var offset = 0;
for (var arrIdx = 0; arrIdx < arrayCount; arrIdx++) {
var arr = typedArrays[arrIdx];
for (var byteIdx = 0, arrLen = arr.length; byteIdx < arrLen; byteIdx++) {
merged[offset++] = arr[byteIdx];
}
}
return merged;
};
exports2.mergeUint8Arrays = function(arrays) {
var totalSize = 0;
for (var idx = 0, len = arrays.length; idx < len; idx++) {
totalSize += arrays[idx].length;
}
var mergedBuffer = new Uint8Array(totalSize);
var offset = 0;
for (var idx = 0, len = arrays.length; idx < len; idx++) {
var array = arrays[idx];
mergedBuffer.set(array, offset);
offset += array.length;
}
return mergedBuffer;
};
exports2.arrayAsString = function(array) {
var str = "";
for (var idx = 0, len = array.length; idx < len; idx++) {
str += strings_1.charFromCode(array[idx]);
}
return str;
};
exports2.byAscendingId = function(a, b) {
return a.id - b.id;
};
exports2.sortedUniq = function(array, indexer) {
var uniq = [];
for (var idx = 0, len = array.length; idx < len; idx++) {
var curr = array[idx];
var prev = array[idx - 1];
if (idx === 0 || indexer(curr) !== indexer(prev)) {
uniq.push(curr);
}
}
return uniq;
};
exports2.reverseArray = function(array) {
var arrayLen = array.length;
for (var idx = 0, len = Math.floor(arrayLen / 2); idx < len; idx++) {
var leftIdx = idx;
var rightIdx = arrayLen - idx - 1;
var temp = array[idx];
array[leftIdx] = array[rightIdx];
array[rightIdx] = temp;
}
return array;
};
exports2.sum = function(array) {
var total = 0;
for (var idx = 0, len = array.length; idx < len; idx++) {
total += array[idx];
}
return total;
};
exports2.range = function(start, end) {
var arr = new Array(end - start);
for (var idx = 0, len = arr.length; idx < len; idx++) {
arr[idx] = start + idx;
}
return arr;
};
exports2.pluckIndices = function(arr, indices) {
var plucked = new Array(indices.length);
for (var idx = 0, len = indices.length; idx < len; idx++) {
plucked[idx] = arr[indices[idx]];
}
return plucked;
};
exports2.canBeConvertedToUint8Array = function(input) {
return input instanceof Uint8Array || input instanceof ArrayBuffer || typeof input === "string";
};
exports2.toUint8Array = function(input) {
if (typeof input === "string") {
return base64_1.decodeFromBase64DataUri(input);
} else if (input instanceof ArrayBuffer) {
return new Uint8Array(input);
} else if (input instanceof Uint8Array) {
return input;
} else {
throw new TypeError("`input` must be one of `string | ArrayBuffer | Uint8Array`");
}
};
}
});
// node_modules/pdf-lib/cjs/utils/async.js
var require_async = __commonJS({
"node_modules/pdf-lib/cjs/utils/async.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.waitForTick = void 0;
exports2.waitForTick = function() {
return new Promise(function(resolve) {
setTimeout(function() {
return resolve();
}, 0);
});
};
}
});
// node_modules/pdf-lib/cjs/utils/unicode.js
var require_unicode = __commonJS({
"node_modules/pdf-lib/cjs/utils/unicode.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.hasUtf16BOM = exports2.utf16Decode = exports2.lowSurrogate = exports2.highSurrogate = exports2.hasSurrogates = exports2.isWithinBMP = exports2.utf16Encode = exports2.utf8Encode = void 0;
var strings_1 = require_strings();
exports2.utf8Encode = function(input, byteOrderMark) {
if (byteOrderMark === void 0) {
byteOrderMark = true;
}
var encoded = [];
if (byteOrderMark)
encoded.push(239, 187, 191);
for (var idx = 0, len = input.length; idx < len; ) {
var codePoint = input.codePointAt(idx);
if (codePoint < 128) {
var byte1 = codePoint & 127;
encoded.push(byte1);
idx += 1;
} else if (codePoint < 2048) {
var byte1 = codePoint >> 6 & 31 | 192;
var byte2 = codePoint & 63 | 128;
encoded.push(byte1, byte2);
idx += 1;
} else if (codePoint < 65536) {
var byte1 = codePoint >> 12 & 15 | 224;
var byte2 = codePoint >> 6 & 63 | 128;
var byte3 = codePoint & 63 | 128;
encoded.push(byte1, byte2, byte3);
idx += 1;
} else if (codePoint < 1114112) {
var byte1 = codePoint >> 18 & 7 | 240;
var byte2 = codePoint >> 12 & 63 | 128;
var byte3 = codePoint >> 6 & 63 | 128;
var byte4 = codePoint >> 0 & 63 | 128;
encoded.push(byte1, byte2, byte3, byte4);
idx += 2;
} else
throw new Error("Invalid code point: 0x" + strings_1.toHexString(codePoint));
}
return new Uint8Array(encoded);
};
exports2.utf16Encode = function(input, byteOrderMark) {
if (byteOrderMark === void 0) {
byteOrderMark = true;
}
var encoded = [];
if (byteOrderMark)
encoded.push(65279);
for (var idx = 0, len = input.length; idx < len; ) {
var codePoint = input.codePointAt(idx);
if (codePoint < 65536) {
encoded.push(codePoint);
idx += 1;
} else if (codePoint < 1114112) {
encoded.push(exports2.highSurrogate(codePoint), exports2.lowSurrogate(codePoint));
idx += 2;
} else
throw new Error("Invalid code point: 0x" + strings_1.toHexString(codePoint));
}
return new Uint16Array(encoded);
};
exports2.isWithinBMP = function(codePoint) {
return codePoint >= 0 && codePoint <= 65535;
};
exports2.hasSurrogates = function(codePoint) {
return codePoint >= 65536 && codePoint <= 1114111;
};
exports2.highSurrogate = function(codePoint) {
return Math.floor((codePoint - 65536) / 1024) + 55296;
};
exports2.lowSurrogate = function(codePoint) {
return (codePoint - 65536) % 1024 + 56320;
};
var ByteOrder;
(function(ByteOrder2) {
ByteOrder2["BigEndian"] = "BigEndian";
ByteOrder2["LittleEndian"] = "LittleEndian";
})(ByteOrder || (ByteOrder = {}));
var REPLACEMENT = "\uFFFD".codePointAt(0);
exports2.utf16Decode = function(input, byteOrderMark) {
if (byteOrderMark === void 0) {
byteOrderMark = true;
}
if (input.length <= 1)
return String.fromCodePoint(REPLACEMENT);
var byteOrder = byteOrderMark ? readBOM(input) : ByteOrder.BigEndian;
var idx = byteOrderMark ? 2 : 0;
var codePoints = [];
while (input.length - idx >= 2) {
var first = decodeValues(input[idx++], input[idx++], byteOrder);
if (isHighSurrogate(first)) {
if (input.length - idx < 2) {
codePoints.push(REPLACEMENT);
} else {
var second = decodeValues(input[idx++], input[idx++], byteOrder);
if (isLowSurrogate(second)) {
codePoints.push(first, second);
} else {
codePoints.push(REPLACEMENT);
}
}
} else if (isLowSurrogate(first)) {
idx += 2;
codePoints.push(REPLACEMENT);
} else {
codePoints.push(first);
}
}
if (idx < input.length)
codePoints.push(REPLACEMENT);
return String.fromCodePoint.apply(String, codePoints);
};
var isHighSurrogate = function(codePoint) {
return codePoint >= 55296 && codePoint <= 56319;
};
var isLowSurrogate = function(codePoint) {
return codePoint >= 56320 && codePoint <= 57343;
};
var decodeValues = function(first, second, byteOrder) {
if (byteOrder === ByteOrder.LittleEndian)
return second << 8 | first;
if (byteOrder === ByteOrder.BigEndian)
return first << 8 | second;
throw new Error("Invalid byteOrder: " + byteOrder);
};
var readBOM = function(bytes) {
return hasUtf16BigEndianBOM(bytes) ? ByteOrder.BigEndian : hasUtf16LittleEndianBOM(bytes) ? ByteOrder.LittleEndian : ByteOrder.BigEndian;
};
var hasUtf16BigEndianBOM = function(bytes) {
return bytes[0] === 254 && bytes[1] === 255;
};
var hasUtf16LittleEndianBOM = function(bytes) {
return bytes[0] === 255 && bytes[1] === 254;
};
exports2.hasUtf16BOM = function(bytes) {
return hasUtf16BigEndianBOM(bytes) || hasUtf16LittleEndianBOM(bytes);
};
}
});
// node_modules/pdf-lib/cjs/utils/numbers.js
var require_numbers = __commonJS({
"node_modules/pdf-lib/cjs/utils/numbers.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.bytesFor = exports2.sizeInBytes = exports2.numberToString = void 0;
exports2.numberToString = function(num) {
var numStr = String(num);
if (Math.abs(num) < 1) {
var e = parseInt(num.toString().split("e-")[1]);
if (e) {
var negative = num < 0;
if (negative)
num *= -1;
num *= Math.pow(10, e - 1);
numStr = "0." + new Array(e).join("0") + num.toString().substring(2);
if (negative)
numStr = "-" + numStr;
}
} else {
var e = parseInt(num.toString().split("+")[1]);
if (e > 20) {
e -= 20;
num /= Math.pow(10, e);
numStr = num.toString() + new Array(e + 1).join("0");
}
}
return numStr;
};
exports2.sizeInBytes = function(n) {
return Math.ceil(n.toString(2).length / 8);
};
exports2.bytesFor = function(n) {
var bytes = new Uint8Array(exports2.sizeInBytes(n));
for (var i = 1; i <= bytes.length; i++) {
bytes[i - 1] = n >> (bytes.length - i) * 8;
}
return bytes;
};
}
});
// node_modules/pdf-lib/cjs/utils/errors.js
var require_errors = __commonJS({
"node_modules/pdf-lib/cjs/utils/errors.js"(exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", { value: true });
exports2.error = void 0;
exports2.error = function(msg) {
throw new Error(msg);
};
}
});
// node_modules/@pdf-lib/standard-fonts/node_modules/pako/lib/utils/common.js
var require_common = __commonJS({
"node_modules/@pdf-lib/standard-fonts/node_modules/pako/lib/utils/common.js"(exports2) {
"use strict";
var TYPED_OK = typeof Uint8Array !== "undefined" && typeof Uint16Array !== "undefined" && typeof Int32Array !== "undefined";
function _has2(obj, key) {
return Object.prototype.hasOwnProperty.call(obj, key);
}
exports2.assign = function(obj) {
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 (_has2(source, p)) {
obj[p] = source[p];
}
}
}
return obj;
};
exports2.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;
}
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;
len = 0;
for (i = 0, l = chunks.length; i < l; i++) {
len += chunks[i].length;
}
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);
}
};
exports2.setTyped = function(on) {
if (on) {
exports2.Buf8 = Uint8Array;
exports2.Buf16 = Uint16Array;
exports2.Buf32 = Int32Array;
exports2.assign(exports2, fnTyped);
} else {
exports2.Buf8 = Array;
exports2.Buf16 = Array;
exports2.Buf32 = Array;
exports2.assign(exports2, fnUntyped);
}
};
exports2.setTyped(TYPED_OK);
}
});
// node_modules/@pdf-lib/standard-fonts/node_modules/pako/lib/zlib/trees.js
var require_trees = __commonJS({
"node_modules/@pdf-lib/standard-fonts/node_modules/pako/lib/zlib/trees.js"(exports2) {
"use strict";
var utils = require_common();
var Z_FIXED2 = 4;
var Z_BINARY2 = 0;
var Z_TEXT2 = 1;
var Z_UNKNOWN2 = 2;
function zero2(buf) {
var len = buf.length;
while (--len >= 0) {
buf[len] = 0;
}
}
var STORED_BLOCK2 = 0;
var STATIC_TREES2 = 1;
var DYN_TREES2 = 2;
var MIN_MATCH2 = 3;
var MAX_MATCH2 = 258;
var LENGTH_CODES2 = 29;
var LITERALS2 = 256;
var L_CODES2 = LITERALS2 + 1 + LENGTH_CODES2;
var D_CODES2 = 30;
var BL_CODES2 = 19;
var HEAP_SIZE2 = 2 * L_CODES2 + 1;
var MAX_BITS2 = 15;
var Buf_size2 = 16;
var MAX_BL_BITS2 = 7;
var END_BLOCK2 = 256;
var REP_3_62 = 16;
var REPZ_3_102 = 17;
var REPZ_11_1382 = 18;
var extra_lbits2 = (
/* 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_dbits2 = (
/* 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_blbits2 = (
/* 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_order2 = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
var DIST_CODE_LEN2 = 512;
var static_ltree2 = new Array((L_CODES2 + 2) * 2);
zero2(static_ltree2);
var static_dtree2 = new Array(D_CODES2 * 2);
zero2(static_dtree2);
var _dist_code2 = new Array(DIST_CODE_LEN2);
zero2(_dist_code2);
var _length_code2 = new Array(MAX_MATCH2 - MIN_MATCH2 + 1);
zero2(_length_code2);
var base_length2 = new Array(LENGTH_CODES2);
zero2(base_length2);
var base_dist2 = new Array(D_CODES2);
zero2(base_dist2);
function StaticTreeDesc2(static_tree, extra_bits, extra_base, elems, max_length) {
this.static_tree = static_tree;
this.extra_bits = extra_bits;
this.extra_base = extra_base;
this.elems = elems;
this.max_length = max_length;
this.has_stree = static_tree && static_tree.length;
}
var static_l_desc2;
var static_d_desc2;
var static_bl_desc2;
function TreeDesc2(dyn_tree, stat_desc) {
this.dyn_tree = dyn_tree;
this.max_code = 0;
this.stat_desc = stat_desc;
}
function d_code2(dist) {
return dist < 256 ? _dist_code2[dist] : _dist_code2[256 + (dist >>> 7)];
}
function put_short2(s, w) {
s.pending_buf[s.pending++] = w & 255;
s.pending_buf[s.pending++] = w >>> 8 & 255;
}
function send_bits2(s, value, length) {
if (s.bi_valid > Buf_size2 - length) {
s.bi_buf |= value << s.bi_valid & 65535;
put_short2(s, s.bi_buf);
s.bi_buf = value >> Buf_size2 - s.bi_valid;
s.bi_valid += length - Buf_size2;
} else {
s.bi_buf |= value << s.bi_valid & 65535;
s.bi_valid += length;
}
}
function send_code2(s, c, tree) {
send_bits2(
s,
tree[c * 2],
tree[c * 2 + 1]
/*.Len*/
);
}
function bi_reverse2(code, len) {
var res = 0;
do {
res |= code & 1;
code >>>= 1;
res <<= 1;
} while (--len > 0);
return res >>> 1;
}
function bi_flush2(s) {
if (s.bi_valid === 16) {
put_short2(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 & 255;
s.bi_buf >>= 8;
s.bi_valid -= 8;
}
}
function gen_bitlen2(s, desc) {
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;
var n, m;
var bits;
var xbits;
var f;
var overflow = 0;
for (bits = 0; bits <= MAX_BITS2; bits++) {
s.bl_count[bits] = 0;
}
tree[s.heap[s.heap_max] * 2 + 1] = 0;
for (h = s.heap_max + 1; h < HEAP_SIZE2; h++) {
n = s.heap[h];
bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
if (bits > max_length) {
bits = max_length;
overflow++;
}
tree[n * 2 + 1] = bits;
if (n > max_code) {
continue;
}
s.bl_count[bits]++;
xbits = 0;
if (n >= base) {
xbits = extra[n - base];
}
f = tree[n * 2];
s.opt_len += f * (bits + xbits);
if (has_stree) {
s.static_len += f * (stree[n * 2 + 1] + xbits);
}
}
if (overflow === 0) {
return;
}
do {
bits = max_length - 1;
while (s.bl_count[bits] === 0) {
bits--;
}
s.bl_count[bits]--;
s.bl_count[bits + 1] += 2;
s.bl_count[max_length]--;
overflow -= 2;
} while (overflow > 0);
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] !== bits) {
s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
tree[m * 2 + 1] = bits;
}
n--;
}
}
}
function gen_codes2(tree, max_code, bl_count) {
var next_code = new Array(MAX_BITS2 + 1);
var code = 0;
var bits;
var n;
for (bits = 1; bits <= MAX_BITS2; bits++) {
next_code[bits] = code = code + bl_count[bits - 1] << 1;
}
for (n = 0; n <= max_code; n++) {
var len = tree[n * 2 + 1];
if (len === 0) {
continue;
}
tree[n * 2] = bi_reverse2(next_code[len]++, len);
}
}
function tr_static_init2() {
var n;
var bits;
var length;
var code;
var dist;
var bl_count = new Array(MAX_BITS2 + 1);
length = 0;
for (code = 0; code < LENGTH_CODES2 - 1; code++) {
base_length2[code] = length;
for (n = 0; n < 1 << extra_lbits2[code]; n++) {
_length_code2[length++] = code;
}
}
_length_code2[length - 1] = code;
dist = 0;
for (code = 0; code < 16; code++) {
base_dist2[code] = dist;
for (n = 0; n < 1 << extra_dbits2[code]; n++) {
_dist_code2[dist++] = code;
}
}
dist >>= 7;
for (; code < D_CODES2; code++) {
base_dist2[code] = dist << 7;
for (n = 0; n < 1 << extra_dbits2[code] - 7; n++) {
_dist_code2[256 + dist++] = code;
}
}
for (bits = 0; bits <= MAX_BITS2; bits++) {
bl_count[bits] = 0;
}
n = 0;
while (n <= 143) {
static_ltree2[n * 2 + 1] = 8;
n++;
bl_count[8]++;
}
while (n <= 255) {
static_ltree2[n * 2 + 1] = 9;
n++;
bl_count[9]++;
}
while (n <= 279) {
static_ltree2[n * 2 + 1] = 7;
n++;
bl_count[7]++;
}
while (n <= 287) {
static_ltree2[n * 2 + 1] = 8;
n++;
bl_count[8]++;
}
gen_codes2(static_ltree2, L_CODES2 + 1, bl_count);
for (n = 0; n < D_CODES2; n++) {
static_dtree2[n * 2 + 1] = 5;
static_dtree2[n * 2] = bi_reverse2(n, 5);
}
static_l_desc2 = new StaticTreeDesc2(static_ltree2, extra_lbits2, LITERALS2 + 1, L_CODES2, MAX_BITS2);
static_d_desc2 = new StaticTreeDesc2(static_dtree2, extra_dbits2, 0, D_CODES2, MAX_BITS2);
static_bl_desc2 = new StaticTreeDesc2(new Array(0), extra_blbits2, 0, BL_CODES2, MAX_BL_BITS2);
}
function init_block2(s) {
var n;
for (n = 0; n < L_CODES2; n++) {
s.dyn_ltree[n * 2] = 0;
}
for (n = 0; n < D_CODES2; n++) {
s.dyn_dtree[n * 2] = 0;
}
for (n = 0; n < BL_CODES2; n++) {
s.bl_tree[n * 2] = 0;
}
s.dyn_ltree[END_BLOCK2 * 2] = 1;
s.opt_len = s.static_len = 0;
s.last_lit = s.matches = 0;
}
function bi_windup2(s) {
if (s.bi_valid > 8) {
put_short2(s, s.bi_buf);
} else if (s.bi_valid > 0) {
s.pending_buf[s.pending++] = s.bi_buf;
}
s.bi_buf = 0;
s.bi_valid = 0;
}
function copy_block(s, buf, len, header) {
bi_windup2(s);
if (header) {
put_short2(s, len);
put_short2(s, ~len);
}
utils.arraySet(s.pending_buf, s.window, buf, len, s.pending);
s.pending += len;
}
function smaller2(tree, n, m, depth) {
var _n2 = n * 2;
var _m2 = m * 2;
return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m];
}
function pqdownheap2(s, tree, k) {
var v = s.heap[k];
var j = k << 1;
while (j <= s.heap_len) {
if (j < s.heap_len && smaller2(tree, s.heap[j + 1], s.heap[j], s.depth)) {
j++;
}
if (smaller2(tree, v, s.heap[j], s.depth)) {
break;
}
s.heap[k] = s.heap[j];
k = j;
j <<= 1;
}
s.heap[k] = v;
}
function compress_block2(s, ltree, dtree) {
var dist;
var lc;
var lx = 0;
var code;
var extra;
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_code2(s, lc, ltree);
} else {
code = _length_code2[lc];
send_code2(s, code + LITERALS2 + 1, ltree);
extra = extra_lbits2[code];
if (extra !== 0) {
lc -= base_length2[code];
send_bits2(s, lc, extra);
}
dist--;
code = d_code2(dist);
send_code2(s, code, dtree);
extra = extra_dbits2[code];
if (extra !== 0) {
dist -= base_dist2[code];
send_bits2(s, dist, extra);
}
}
} while (lx < s.last_lit);
}
send_code2(s, END_BLOCK2, ltree);
}
function build_tree2(s, desc) {
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;
var max_code = -1;
var node;
s.heap_len = 0;
s.heap_max = HEAP_SIZE2;
for (n = 0; n < elems; n++) {
if (tree[n * 2] !== 0) {
s.heap[++s.heap_len] = max_code = n;
s.depth[n] = 0;
} else {
tree[n * 2 + 1] = 0;
}
}
while (s.heap_len < 2) {
node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
tree[node * 2] = 1;
s.depth[node] = 0;
s.opt_len--;
if (has_stree) {
s.static_len -= stree[node * 2 + 1];
}
}
desc.max_code = max_code;
for (n = s.heap_len >> 1; n >= 1; n--) {
pqdownheap2(s, tree, n);
}
node = elems;
do {
n = s.heap[
1
/*SMALLEST*/
];
s.heap[
1
/*SMALLEST*/
] = s.heap[s.heap_len--];
pqdownheap2(
s,
tree,
1
/*SMALLEST*/
);
m = s.heap[
1
/*SMALLEST*/
];
s.heap[--s.heap_max] = n;
s.heap[--s.heap_max] = m;
tree[node * 2] = tree[n * 2] + tree[m * 2];
s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
tree[n * 2 + 1] = tree[m * 2 + 1] = node;
s.heap[
1
/*SMALLEST*/
] = node++;
pqdownheap2(
s,
tree,
1
/*SMALLEST*/
);
} while (s.heap_len >= 2);
s.heap[--s.heap_max] = s.heap[
1
/*SMALLEST*/
];
gen_bitlen2(s, desc);
gen_codes2(tree, max_code, s.bl_count);
}
function scan_tree2(s, tree, max_code) {
var n;
var prevlen = -1;
var curlen;
var nextlen = tree[0 * 2 + 1];
var count = 0;
var max_count = 7;
var min_count = 4;
if (nextlen === 0) {
max_count = 138;
min_count = 3;
}
tree[(max_code + 1) * 2 + 1] = 65535;
for (n = 0; n <= max_code; n++) {
curlen = nextlen;
nextlen = tree[(n + 1) * 2 + 1];
if (++count < max_count && curlen === nextlen) {
continue;
} else if (count < min_count) {
s.bl_tree[curlen * 2] += count;
} else if (curlen !== 0) {
if (curlen !== prevlen) {
s.bl_tree[curlen * 2]++;
}
s.bl_tree[REP_3_62 * 2]++;
} else if (count <= 10) {
s.bl_tree[REPZ_3_102 * 2]++;
} else {
s.bl_tree[REPZ_11_1382 * 2]++;
}
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;
}
}
}
function send_tree2(s, tree, max_code) {
var n;
var prevlen = -1;
var curlen;
var nextlen = tree[0 * 2 + 1];
var count = 0;
var max_count = 7;
var min_count = 4;
if (nextlen === 0) {
max_count = 138;
min_count = 3;
}
for (n = 0; n <= max_code; n++) {
curlen = nextlen;
nextlen = tree[(n + 1) * 2 + 1];
if (++count < max_count &&