: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
mergedDict._map[name] = subDict;
return mergedDict.size > 0 ? mergedDict : Dict.empty;
const dict = new Dict(this.xref);
for (const key of this.getKeys()) {
dict.set(key, this.getRaw(key));
return `${this.num}R${this.gen}`;
const ref = RefCache[str];
const m = /^(\d+)R(\d*)$/.exec(str);
if (!m || m[1] === "0") {
return RefCache[str] = new Ref(parseInt(m[1]), !m[2] ? 0 : parseInt(m[2]));
const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
return RefCache[key] ||= new Ref(num, gen);
constructor(parent = null) {
this._set = new Set(parent?._set);
return this._set.has(ref.toString());
this._set.add(ref.toString());
this._set.delete(ref.toString());
return this._set.values();
return this._map.get(ref.toString());
return this._map.has(ref.toString());
this._map.set(ref.toString(), obj);
putAlias(ref, aliasRef) {
this._map.set(ref.toString(), this.get(aliasRef));
return this._map.values();
for (const [ref, value] of this._map) {
yield [Ref.fromString(ref), value];
function isName(v, name) {
return v instanceof Name && (name === undefined || v.name === name);
return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
function isDict(v, type) {
return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
function isRefsEqual(v1, v2) {
return v1.num === v2.num && v1.gen === v2.gen;
;// CONCATENATED MODULE: ./src/core/base_stream.js
if (this.constructor === BaseStream) {
unreachable("Cannot initialize BaseStream.");
unreachable("Abstract getter `length` accessed");
unreachable("Abstract getter `isEmpty` accessed");
return shadow(this, "isDataLoaded", true);
unreachable("Abstract method `getByte` called");
unreachable("Abstract method `getBytes` called");
const peekedByte = this.getByte();
const bytes = this.getBytes(length);
this.pos -= bytes.length;
const b0 = this.getByte();
const b1 = this.getByte();
if (b0 === -1 || b1 === -1) {
const b0 = this.getByte();
const b1 = this.getByte();
const b2 = this.getByte();
const b3 = this.getByte();
return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
getByteRange(begin, end) {
unreachable("Abstract method `getByteRange` called");
return bytesToString(this.getBytes(length));
unreachable("Abstract method `reset` called");
unreachable("Abstract method `moveStart` called");
makeSubStream(start, length, dict = null) {
unreachable("Abstract method `makeSubStream` called");
;// CONCATENATED MODULE: ./src/core/core_utils.js
const PDF_VERSION_REGEXP = /^[1-9]\.\d$/;
function getLookupTableFactory(initializer) {
lookup = Object.create(null);
class MissingDataException extends BaseException {
constructor(begin, end) {
super(`Missing data [${begin}, ${end})`, "MissingDataException");
class ParserEOFException extends BaseException {
super(msg, "ParserEOFException");
class XRefEntryException extends BaseException {
super(msg, "XRefEntryException");
class XRefParseException extends BaseException {
super(msg, "XRefParseException");
function arrayBuffersToBytes(arr) {
const length = arr.length;
return new Uint8Array(0);
return new Uint8Array(arr[0]);
for (let i = 0; i < length; i++) {
dataLength += arr[i].byteLength;
const data = new Uint8Array(dataLength);
for (let i = 0; i < length; i++) {
const item = new Uint8Array(arr[i]);
function getInheritableProperty({
const visited = new RefSet();
while (dict instanceof Dict && !(dict.objId && visited.has(dict.objId))) {
const value = getArray ? dict.getArray(key) : dict.get(key);
if (value !== undefined) {
(values ||= []).push(value);
dict = dict.get("Parent");
const ROMAN_NUMBER_MAP = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
function toRomanNumerals(number, lowerCase = false) {
assert(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
romanBuf.push(ROMAN_NUMBER_MAP[pos]);
romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
const romanStr = romanBuf.join("");
return lowerCase ? romanStr.toLowerCase() : romanStr;
return Math.ceil(Math.log2(x));
function readInt8(data, offset) {
return data[offset] << 24 >> 24;
function readUint16(data, offset) {
return data[offset] << 8 | data[offset + 1];
function readUint32(data, offset) {
return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
function isWhiteSpace(ch) {
return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
function isBooleanArray(arr, len) {
return Array.isArray(arr) && (len === null || arr.length === len) && arr.every(x => typeof x === "boolean");
function isNumberArray(arr, len) {
return Array.isArray(arr) && (len === null || arr.length === len) && arr.every(x => typeof x === "number");
function lookupMatrix(arr, fallback) {
return isNumberArray(arr, 6) ? arr : fallback;
function lookupRect(arr, fallback) {
return isNumberArray(arr, 4) ? arr : fallback;
function lookupNormalRect(arr, fallback) {
return isNumberArray(arr, 4) ? Util.normalizeRect(arr) : fallback;
function parseXFAPath(path) {
const positionPattern = /(.+)\[(\d+)\]$/;
return path.split(".").map(component => {
const m = component.match(positionPattern);
function escapePDFName(str) {
for (let i = 0, ii = str.length; i < ii; i++) {
const char = str.charCodeAt(i);
if (char < 0x21 || char > 0x7e || char === 0x23 || char === 0x28 || char === 0x29 || char === 0x3c || char === 0x3e || char === 0x5b || char === 0x5d || char === 0x7b || char === 0x7d || char === 0x2f || char === 0x25) {
buffer.push(str.substring(start, i));
buffer.push(`#${char.toString(16)}`);
if (buffer.length === 0) {
if (start < str.length) {
buffer.push(str.substring(start, str.length));
function escapeString(str) {
return str.replaceAll(/([()\\\n\r])/g, match => {
} else if (match === "\r") {
function _collectJS(entry, xref, list, parents) {
if (entry instanceof Ref) {
if (parents.has(entry)) {
entry = xref.fetch(entry);
if (Array.isArray(entry)) {
for (const element of entry) {
_collectJS(element, xref, list, parents);
} else if (entry instanceof Dict) {
if (isName(entry.get("S"), "JavaScript")) {
const js = entry.get("JS");
if (js instanceof BaseStream) {
} else if (typeof js === "string") {
code &&= stringToPDFString(code).replaceAll("\x00", "");
_collectJS(entry.getRaw("Next"), xref, list, parents);
function collectActions(xref, dict, eventType) {
const actions = Object.create(null);
const additionalActionsDicts = getInheritableProperty({
if (additionalActionsDicts) {
for (let i = additionalActionsDicts.length - 1; i >= 0; i--) {
const additionalActions = additionalActionsDicts[i];
if (!(additionalActions instanceof Dict)) {
for (const key of additionalActions.getKeys()) {
const action = eventType[key];
const actionDict = additionalActions.getRaw(key);
const parents = new RefSet();
_collectJS(actionDict, xref, list, parents);
const actionDict = dict.get("A");
const parents = new RefSet();
_collectJS(actionDict, xref, list, parents);
return objectSize(actions) > 0 ? actions : null;
function* codePointIter(str) {
for (let i = 0, ii = str.length; i < ii; i++) {
const char = str.codePointAt(i);
if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
function encodeToXmlString(str) {
for (let i = 0, ii = str.length; i < ii; i++) {
const char = str.codePointAt(i);
if (0x20 <= char && char <= 0x7e) {
const entity = XMLEntities[char];
buffer.push(str.substring(start, i));
buffer.push(str.substring(start, i));
buffer.push(`&#x${char.toString(16).toUpperCase()};`);
if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
if (buffer.length === 0) {
if (start < str.length) {
buffer.push(str.substring(start, str.length));
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
