lucasw89/bentopdf
1
0
Fork 0
mirror of https://github.com/alam00000/bentopdf.git synced 2026-11-06 08:08:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
75e76c96194e8e69c9ce2b2ad38a63905f45cca1
bentopdf/src/js/editcore/core.js
T

1840 lines
51 KiB
JavaScript
Raw Blame History

import { createEngineModule, ENGINE_BUILD } from './engine-loader.js';
export const EC_BUILD = ENGINE_BUILD;
const createEditCore = createEngineModule;
const devBust = '';
import { applyType3LeftoverSurgery } from './type3surgery.js';
const RUN_SIZE = 60;
const FMT_SIZE = 36;
export const OBJ = {
UNKNOWN: 0,
TEXT: 1,
PATH: 2,
IMAGE: 3,
SHADING: 4,
FORM: 5,
};
export function sfntCovers(bytes, cps) {
try {
const u16 = (o) => (bytes[o] << 8) | bytes[o + 1];
const u32 = (o) =>
((bytes[o] << 24) |
(bytes[o + 1] << 16) |
(bytes[o + 2] << 8) |
bytes[o + 3]) >>>
0;
let base = 0;
if (u32(0) === 0x74746366) base = u32(12);
const num = u16(base + 4);
let cmap = 0;
for (let i = 0; i < num; i++) {
const o = base + 12 + i * 16;
if (u32(o) === 0x636d6170) {
cmap = u32(o + 8);
break;
}
}
if (!cmap) return false;
const nt = u16(cmap + 2);
let sub = 0,
fmt = -1,
score = -1;
for (let i = 0; i < nt; i++) {
const rec = cmap + 4 + i * 8;
const pid = u16(rec),
eid = u16(rec + 2),
off = cmap + u32(rec + 4);
const f = u16(off);
const sc =
pid === 3 && eid === 10
? 3
: pid === 3 && eid === 1
? 2
: pid === 0
? 1
: 0;
if (sc > score && (f === 4 || f === 12)) {
score = sc;
sub = off;
fmt = f;
}
}
if (!sub) return false;
const lookup4 = (cp) => {
if (cp > 0xffff) return 0;
const segX2 = u16(sub + 6);
for (let s2 = 0; s2 < segX2; s2 += 2) {
const end = u16(sub + 14 + s2);
if (cp <= end) {
const start = u16(sub + 16 + segX2 + s2);
if (cp < start) return 0;
const delta = u16(sub + 16 + segX2 * 2 + s2);
const roBase = sub + 16 + segX2 * 3 + s2;
const ro = u16(roBase);
if (!ro) return (cp + delta) & 0xffff;
const g = u16(roBase + ro + (cp - start) * 2);
return g ? (g + delta) & 0xffff : 0;
}
}
return 0;
};
const lookup12 = (cp) => {
const n = u32(sub + 12);
let lo = 0,
hi = n - 1;
while (lo <= hi) {
const mid = (lo + hi) >> 1,
g = sub + 16 + mid * 12;
const s0 = u32(g),
e0 = u32(g + 4);
if (cp < s0) hi = mid - 1;
else if (cp > e0) lo = mid + 1;
else return u32(g + 8) + (cp - s0);
}
return 0;
};
for (const cp of cps) {
if (cp === 0x20 || cp === 0x0a || cp === 0x0d) continue;
if ((fmt === 12 ? lookup12(cp) : lookup4(cp)) === 0) return false;
}
return true;
} catch {
return false;
}
}
export function scriptFallbackFamilies(cps) {
const TABLE = [
[
[
[0x0600, 0x06ff],
[0x0750, 0x077f],
[0xfb50, 0xfdff],
[0xfe70, 0xfeff],
],
[
'Geeza Pro',
'Al Nile',
'Damascus',
'Baghdad',
'Noto Naskh Arabic',
'Noto Sans Arabic',
'Arial Unicode MS',
'Arial',
],
],
[
[
[0x0590, 0x05ff],
[0xfb1d, 0xfb4f],
],
[
'Arial Hebrew',
'Lucida Grande',
'Noto Sans Hebrew',
'Arial Unicode MS',
'Arial',
],
],
[
[[0x0900, 0x097f]],
[
'Kohinoor Devanagari',
'Devanagari MT',
'ITF Devanagari',
'Noto Sans Devanagari',
'Arial Unicode MS',
],
],
[
[[0x0980, 0x09ff]],
['Kohinoor Bangla', 'Bangla MN', 'Noto Sans Bengali', 'Arial Unicode MS'],
],
[
[[0x0a00, 0x0a7f]],
['Gurmukhi MN', 'Noto Sans Gurmukhi', 'Arial Unicode MS'],
],
[
[[0x0a80, 0x0aff]],
[
'Kohinoor Gujarati',
'Gujarati MT',
'Noto Sans Gujarati',
'Arial Unicode MS',
],
],
[
[[0x0b80, 0x0bff]],
['Tamil MN', 'InaiMathi', 'Noto Sans Tamil', 'Arial Unicode MS'],
],
[
[[0x0c00, 0x0c7f]],
['Kohinoor Telugu', 'Telugu MN', 'Noto Sans Telugu', 'Arial Unicode MS'],
],
[
[[0x0c80, 0x0cff]],
['Kannada MN', 'Noto Sans Kannada', 'Arial Unicode MS'],
],
[
[[0x0d00, 0x0d7f]],
['Malayalam MN', 'Noto Sans Malayalam', 'Arial Unicode MS'],
],
[
[[0x0e00, 0x0e7f]],
['Thonburi', 'Sukhumvit Set', 'Noto Sans Thai', 'Arial Unicode MS'],
],
[
[
[0x3040, 0x30ff],
[0x3400, 0x9fff],
[0xf900, 0xfaff],
],
[
'PingFang SC',
'Hiragino Sans',
'Apple SD Gothic Neo',
'Noto Sans CJK SC',
'Arial Unicode MS',
],
],
[
[[0xac00, 0xd7af]],
['Apple SD Gothic Neo', 'Noto Sans KR', 'Arial Unicode MS'],
],
];
const out = [];
for (const cp of cps) {
for (const [ranges, fams] of TABLE) {
if (ranges.some(([a, b]) => cp >= a && cp <= b))
for (const f of fams) if (!out.includes(f)) out.push(f);
}
}
return out;
}
const PAGE_CACHE_MAX = 6;
export class PdfEngine {
static localFonts = new Map();
constructor(module) {
this.M = module;
this.doc = 0;
this.page = 0;
this.session = 0;
this.pageIndex = 0;
this.pageCount = 0;
this.pageWidth = 0;
this.pageHeight = 0;
this._docBuf = 0;
this._providerPtr = 0;
}
_makeProvider() {
const M = this.M;
return M.addFunction(
(ctx, familyPtr, bold, italic, cps, n, outData, outSize) => {
let fam = M.UTF8ToString(familyPtr);
fam = fam.replace(/ (serif|mono)$/, '');
const want = [];
for (let i = 0; i < n; i++) want.push(M.HEAPU32[(cps >> 2) + i]);
const sk = '|' + (bold ? 1 : 0) + (italic ? 1 : 0);
const names = [fam, ...scriptFallbackFamilies(want)];
let bytes = null;
for (const nm of names) {
for (const k of [nm + sk, nm]) {
const b = PdfEngine.localFonts.get(k);
if (b && b.length && (!want.length || sfntCovers(b, want))) {
bytes = b;
break;
}
}
if (bytes) break;
}
if (!bytes || !bytes.length) return 0;
const buf = M._ec_buffer_alloc(bytes.length);
if (!buf) return 0;
M.HEAPU8.set(bytes, buf);
M.HEAPU32[outData >> 2] = buf;
M.HEAPU32[outSize >> 2] = bytes.length;
return 1;
},
'iiiiiiiii'
);
}
static async create() {
const M = await createEditCore(
devBust
? {
locateFile: (f, prefix) => `${prefix}${f}?v=${devBust}`,
}
: undefined
);
const cfg = M._malloc(48);
M.HEAPU8.fill(0, cfg, cfg + 48);
M.HEAPU32[cfg >> 2] = 2;
M._FPDF_InitLibraryWithConfig(cfg);
M._free(cfg);
return new PdfEngine(M);
}
static disambiguateSubsetFonts(bytes) {
const s = new TextDecoder('latin1').decode(bytes);
const fonts = [];
for (const m of s.matchAll(/(\d+)\s+0\s+obj\b/g)) {
const end = s.indexOf('endobj', m.index);
if (end < 0) continue;
const body = s.slice(m.index, end);
if (!/\/Type\s*\/Font\b/.test(body)) continue;
const bf = body.match(/\/BaseFont\s*\/([A-Z]{6})\+([^\s/\[\]<>()]+)/);
if (!bf) continue;
const fd = body.match(/\/FontDescriptor\s+(\d+)\s+0\s+R/);
fonts.push({
obj: Number(m[1]),
tagAt: m.index + bf.index + bf[0].indexOf(bf[1]),
tag: bf[1],
name: bf[2],
desc: fd ? Number(fd[1]) : 0,
});
}
if (!fonts.length) return bytes;
const containerFonts = new Set();
for (const m of s.matchAll(/(\d+)\s+0\s+obj\b/g)) {
const end = s.indexOf('endobj', m.index);
if (end < 0) continue;
const body = s.slice(m.index, end);
if (!/\/Subtype\s*\/Form\b/.test(body)) continue;
const fi = body.indexOf('/Font');
if (fi < 0) continue;
for (const r of body.slice(fi, fi + 800).matchAll(/(\d+)\s+0\s+R/g))
containerFonts.add(Number(r[1]));
}
if (!containerFonts.size) return bytes;
const groups = new Map();
for (const f of fonts) {
const k = f.tag + '+' + f.name;
if (!groups.has(k)) groups.set(k, []);
groups.get(k).push(f);
}
const taken = new Set(fonts.map((f) => f.tag));
const tagFor = (n) => {
let t = '';
for (let i = 0; i < 6; i++) {
t = String.fromCharCode(65 + (n % 26)) + t;
n = Math.floor(n / 26);
}
return t;
};
let seq = 0;
const nextTag = () => {
let t;
do {
t = tagFor(seq++);
} while (taken.has(t));
taken.add(t);
return t;
};
const esc = (x) => x.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
const faces = new Set(fonts.map((f) => f.name));
const edits = [];
for (const [, list] of groups) {
if (list.length < 2) continue;
if (
!list.some((f) => containerFonts.has(f.obj)) ||
!list.some((f) => !containerFonts.has(f.obj))
)
continue;
for (const f of list) {
if (!containerFonts.has(f.obj) || !f.name.length) continue;
let face = null;
for (let c = 0; c < 26 && !face; c++) {
const cand = f.name.slice(0, -1) + String.fromCharCode(65 + c);
if (!faces.has(cand)) face = cand;
}
if (!face) continue;
faces.add(face);
const tag = nextTag(),
lastCh = face[face.length - 1];
edits.push([f.tagAt, tag], [f.tagAt + 7 + f.name.length - 1, lastCh]);
if (!f.desc) continue;
const dm = s.match(
new RegExp('(?:^|[^0-9])(' + f.desc + '\\s+0\\s+obj\\b)')
);
if (!dm) continue;
const dAt = dm.index + dm[0].indexOf(dm[1]);
const dEnd = s.indexOf('endobj', dAt);
const dBody = s.slice(dAt, dEnd < 0 ? undefined : dEnd);
const fn = dBody.match(
new RegExp('/FontName\\s*/(' + f.tag + ')\\+' + esc(f.name))
);
if (!fn) continue;
const at = dAt + fn.index + fn[0].indexOf(fn[1]);
edits.push([at, tag], [at + 7 + f.name.length - 1, lastCh]);
}
}
if (!edits.length) return bytes;
const out = new Uint8Array(bytes);
for (const [at, text] of edits) {
for (let i = 0; i < text.length; i++) out[at + i] = text.charCodeAt(i);
}
return out;
}
open(bytes, password, _reentrant) {
bytes = PdfEngine.disambiguateSubsetFonts(bytes);
this._originalBytes = bytes;
this.close();
const M = this.M;
const buf = M._malloc(bytes.length);
M.HEAPU8.set(bytes, buf);
let pw = 0;
if (password) {
const n = M.lengthBytesUTF8(password) + 1;
pw = M._malloc(n);
M.stringToUTF8(password, pw, n);
}
const doc = M._FPDF_LoadMemDocument64(buf, bytes.length, pw);
if (pw) M._free(pw);
if (!doc) {
const err = M._FPDF_GetLastError ? M._FPDF_GetLastError() : -1;
M._free(buf);
this.lastOpenError = err;
const e = new Error(
err === 4
? 'This PDF is password-protected.'
: 'This file could not be opened as a PDF.'
);
e.passwordRequired = err === 4;
throw e;
}
this._docBuf = buf;
this.doc = doc;
if (!this._providerPtr) this._providerPtr = this._makeProvider();
this.session = M._ec_session_create(doc, this._providerPtr, 0);
if (M._ec_set_flatten_forms) {
const usesPattern = /\/Pattern\b/.test(
new TextDecoder('latin1').decode(
bytes.subarray(0, Math.min(bytes.length, 8 << 20))
)
);
this._usesPattern = usesPattern;
M._ec_set_flatten_forms(this.session, usesPattern ? 0 : 1);
}
this.pageCount = M._FPDF_GetPageCount(doc);
this._normalized = new Set();
this._reencoded = new Set();
this._regenHostile = new Set();
this._editedPages = new Set();
this._t3seg = null;
this._t3state = {};
this._t3anchors = {};
this._fragilePages = null;
this.loadPage(0);
if (!_reentrant) {
const info = this.documentInfo();
this.security = info;
if (info.encrypted && !info.signatures) {
const clear = this.save();
if (clear && clear.length) {
this.open(clear, null, true);
this.security = { ...info, strippedOnLoad: true };
}
}
}
}
reopen(bytes, pageIndex) {
const keep = this.pageIndex;
const orig = this._originalBytes;
const edited = this._editedPages;
const t3seg = this._t3seg;
const fragile = this._fragilePages;
this._splicePlans = null;
this._spliceOk = false;
this.open(bytes);
if (orig) this._originalBytes = orig;
if (edited) this._editedPages = edited;
if (fragile) this.setFragilePages([...fragile]);
if (t3seg) this._t3seg = t3seg;
this.loadPage(Math.min(pageIndex ?? keep, this.pageCount - 1));
}
setType3Seg(seg) {
if (seg && Object.keys(seg).length) this._t3seg = seg;
}
_t3readState() {
const ptr = this.M._ec_page_text_state(this.session, this.page);
if (!ptr) return null;
let st = null;
try {
st = JSON.parse(this.M.UTF8ToString(ptr));
} catch {}
this.M._ec_string_free(ptr);
return st;
}
_t3anchor(st) {
const seg = this._t3seg?.[this.pageIndex];
if (!seg || !st) return;
const anchors = ((this._t3anchors ||= {})[this.pageIndex] ||= {});
for (const o of st) {
if (!o.t3 || !o.glyphs || !o.glyphs.length) continue;
if (anchors[o.font] != null) continue;
const oCodes = o.glyphs.map((g) => g[0]);
const hit = seg.tjs.find(
(tj) =>
Math.abs(tj.e - o.m[4]) < 0.05 &&
Math.abs(tj.f - o.m[5]) < 0.05 &&
tj.codes.length >= oCodes.length &&
oCodes.every((c, k) => c === tj.codes[k])
);
if (hit) anchors[o.font] = hit.font;
}
}
close() {
const M = this.M;
if (this._pageCache) {
for (const [, handle] of this._pageCache)
if (handle && handle !== this.page) M._FPDF_ClosePage(handle);
this._pageCache.clear();
}
if (this.page) M._FPDF_ClosePage(this.page);
if (this.session) M._ec_session_destroy(this.session);
if (this.doc) M._FPDF_CloseDocument(this.doc);
if (this._docBuf) M._free(this._docBuf);
this.page = this.session = this.doc = this._docBuf = 0;
}
loadPage(index) {
const M = this.M;
this.renderParagraphLiveEnd();
if (this.page && this._pageDirty) this.generateContent();
const cache = (this._pageCache ||= new Map());
if (this.page) cache.set(this.pageIndex, this.page);
let handle = cache.get(index);
if (handle) cache.delete(index);
else handle = M._FPDF_LoadPage(this.doc, index);
cache.set(index, handle);
this.page = handle;
while (cache.size > PAGE_CACHE_MAX) {
let victim = null;
for (const key of cache.keys()) {
if (key === index || this.pinnedPages?.has(key)) continue;
victim = key;
break;
}
if (victim === null) break;
const dead = cache.get(victim);
cache.delete(victim);
if (dead) {
this.M._ec_history_drop_page?.(this.session, dead);
M._FPDF_ClosePage(dead);
}
this.onPageEvicted?.(victim);
}
this.pageIndex = index;
this._pageDirty = false;
this.pageWidth = M._FPDF_GetPageWidthF(this.page);
this.pageHeight = M._FPDF_GetPageHeightF(this.page);
if (this._fragilePages?.has(index)) {
M._ec_mark_fonts_fragile(this.session, this.page);
}
this._readPageTransform();
}
setFragilePages(pages) {
this._fragilePages = new Set(pages || []);
if (this.page && this._fragilePages.has(this.pageIndex)) {
this.M._ec_mark_fonts_fragile(this.session, this.page);
}
}
pageWasNormalized() {
return !!this._reencoded?.has(this.pageIndex);
}
normalizeFontsForEdit() {
if (!this.session || this._normalized?.has(this.pageIndex)) return;
(this._normalized ||= new Set()).add(this.pageIndex);
const lossy = this.M._ec_page_regen_is_lossy(
this.session,
this.page,
this.pageIndex
);
if (lossy === 2) {
(this._regenHostile ||= new Set()).add(this.pageIndex);
return 0;
}
if (lossy === 3) {
return 0;
}
if (lossy) {
const rebuilt = this.M._ec_reencode_page_fonts(this.session, this.page);
this._pageDirty = true;
if (rebuilt > 0) (this._reencoded ||= new Set()).add(this.pageIndex);
return rebuilt;
}
return 0;
}
pageRegenHostile() {
return !!this._regenHostile?.has(this.pageIndex);
}
documentInfo() {
const M = this.M;
const ptr = M._ec_document_info(this.doc);
if (!ptr) return { pages: 0, signatures: 0 };
const j = M.UTF8ToString(ptr);
M._ec_string_free(ptr);
return JSON.parse(j);
}
metaText(tag) {
const M = this.M;
const kp = M._malloc(tag.length + 1);
for (let i = 0; i < tag.length; i++) M.HEAPU8[kp + i] = tag.charCodeAt(i);
M.HEAPU8[kp + tag.length] = 0;
const n = M._FPDF_GetMetaText(this.doc, kp, 0, 0);
let out = '';
if (n > 2) {
const bp = M._malloc(n);
M._FPDF_GetMetaText(this.doc, kp, bp, n);
const chars = [];
for (let i = 0; i + 1 < n - 1; i += 2)
chars.push(M.HEAPU8[bp + i] | (M.HEAPU8[bp + i + 1] << 8));
out = String.fromCharCode(...chars);
M._free(bp);
}
M._free(kp);
return out;
}
static sniffPdfA(bytes) {
const probe = 'pdfaid:part';
const limit = Math.min(bytes.length, 4 << 20);
outer: for (let i = 0; i + probe.length < limit; i++) {
if (bytes[i] !== 112) continue;
for (let j = 0; j < probe.length; j++) {
if (bytes[i + j] !== probe.charCodeAt(j)) continue outer;
}
return true;
}
return false;
}
buildModel() {
const M = this.M;
if (this._pageStale) {
this.renderParagraphLiveEnd();
if (this._pageDirty) this.generateContent();
M._FPDF_ClosePage(this.page);
this.page = M._FPDF_LoadPage(this.doc, this.pageIndex);
this._pageCache?.set(this.pageIndex, this.page);
this.onPageEvicted?.(this.pageIndex);
this._pageStale = false;
this._pageDirty = false;
}
if (this._t3seg && this._t3seg[this.pageIndex]) {
const st = this._t3readState();
if (st) this._t3anchor(st);
}
const ptr = M._ec_build_page_model(this.session, this.page);
if (!ptr) return [];
const json = M.UTF8ToString(ptr);
M._ec_string_free(ptr);
this._readPageTransform();
return JSON.parse(json).paragraphs;
}
_readPageTransform() {
const M = this.M;
if (!this.session || !this.page) return;
const cp = M._malloc(24);
M._ec_page_transform(this.session, this.page, cp);
this.pageT = Array.from(
{ length: 6 },
(_, i) => M.HEAPF32[(cp + i * 4) >> 2]
);
M._free(cp);
this.cropX = -this.pageT[4];
this.cropY = -this.pageT[5];
}
toModel(x, y) {
const t = this.pageT || [1, 0, 0, 1, 0, 0];
return { x: t[0] * x + t[2] * y + t[4], y: t[1] * x + t[3] * y + t[5] };
}
toUser(x, y) {
const t = this.pageT || [1, 0, 0, 1, 0, 0];
const det = t[0] * t[3] - t[1] * t[2] || 1;
const dx = x - t[4],
dy = y - t[5];
return {
x: (t[3] * dx - t[2] * dy) / det,
y: (-t[1] * dx + t[0] * dy) / det,
};
}
_allocStr(s) {
const M = this.M;
const n = M.lengthBytesUTF8(s || '') + 1;
const p = M._malloc(n);
M.stringToUTF8(s || '', p, n);
return p;
}
_writeRuns(runs) {
const M = this.M;
const arr = M._malloc(RUN_SIZE * runs.length);
const strs = [];
runs.forEach((r, i) => {
const b = arr + i * RUN_SIZE;
const tp = this._allocStr(r.text);
const fp = this._allocStr(r.family || '');
strs.push(tp, fp);
M.HEAPU32[(b + 0) >> 2] = tp;
M.HEAPU32[(b + 4) >> 2] = fp;
M.HEAP32[(b + 8) >> 2] = r.bold === 2 ? 2 : r.bold ? 1 : 0;
M.HEAP32[(b + 12) >> 2] = r.italic === 2 ? 2 : r.italic ? 1 : 0;
M.HEAPF32[(b + 16) >> 2] = r.size;
M.HEAPU32[(b + 20) >> 2] = r.rgba >>> 0;
M.HEAP32[(b + 24) >> 2] = r.underline ? 1 : 0;
M.HEAP32[(b + 28) >> 2] = r.strike ? 1 : 0;
M.HEAP32[(b + 32) >> 2] = r.script | 0;
M.HEAP32[(b + 36) >> 2] = r.sourceIndex == null ? -1 : r.sourceIndex;
M.HEAP32[(b + 40) >> 2] = r.renderMode | 0;
M.HEAPU32[(b + 44) >> 2] = (r.strokeRgba || 0) >>> 0;
M.HEAPF32[(b + 48) >> 2] = r.strokeWidth || 1;
M.HEAPF32[(b + 52) >> 2] = r.hScale || 1;
M.HEAPF32[(b + 56) >> 2] = r.rise || 0;
});
return { arr, strs, count: runs.length };
}
_writeFmt(fmt) {
const M = this.M;
const p = M._malloc(FMT_SIZE);
M.HEAP32[(p + 0) >> 2] = fmt.align | 0;
M.HEAPF32[(p + 4) >> 2] = fmt.lineSpacing;
M.HEAPF32[(p + 8) >> 2] = fmt.charSpacing || 0;
M.HEAPF32[(p + 12) >> 2] = fmt.paraSpacing || 0;
M.HEAPF32[(p + 16) >> 2] = fmt.wordSpacing || 0;
M.HEAPF32[(p + 20) >> 2] = fmt.firstIndent || 0;
M.HEAPF32[(p + 24) >> 2] = fmt.hangIndent || 0;
M.HEAP32[(p + 28) >> 2] = fmt.dir | 0;
M.HEAP32[(p + 32) >> 2] = fmt.listLevel | 0;
return p;
}
_free(alloc) {
for (const s of alloc.strs) this.M._free(s);
this.M._free(alloc.arr);
}
_decode(ptr) {
if (!ptr) return null;
const j = this.M.UTF8ToString(ptr);
this.M._ec_string_free(ptr);
return JSON.parse(j);
}
previewParagraph(id, runs, fmt) {
const a = this._writeRuns(runs);
const f = this._writeFmt(fmt);
const ptr = this.M._ec_preview_paragraph(
this.session,
this.page,
id,
a.arr,
a.count,
f
);
this._free(a);
this.M._free(f);
if (!ptr) return null;
const json = this.M.UTF8ToString(ptr);
this.M._ec_string_free(ptr);
try {
return JSON.parse(json);
} catch {
return null;
}
}
commitParagraph(id, runs, fmt) {
this._pageDirty = true;
const a = this._writeRuns(runs);
const f = this._writeFmt(fmt);
const out = this._decode(
this.M._ec_commit_paragraph(
this.session,
this.page,
id,
a.arr,
a.count,
f
)
);
this._free(a);
this.M._free(f);
return out;
}
renderParagraphLive(id, runs, fmt, scale, mx, my, mw, mh) {
const M = this.M;
const a = this._writeRuns(runs);
const f = this._writeFmt(fmt);
const wp = M._malloc(8);
M.HEAP32[wp >> 2] = 0;
M.HEAP32[(wp + 4) >> 2] = 0;
const ptr = M._ec_render_paragraph_live(
this.session,
this.page,
id,
a.arr,
a.count,
f,
scale,
mx,
my,
mw,
mh,
wp,
wp + 4
);
const w = M.HEAP32[wp >> 2],
h = M.HEAP32[(wp + 4) >> 2];
M._free(wp);
this._free(a);
M._free(f);
if (!ptr || !w || !h) return null;
const data = new Uint8ClampedArray(M.HEAPU8.subarray(ptr, ptr + w * h * 4));
M._ec_string_free(ptr);
return { width: w, height: h, data };
}
renderPageRegion(fullW, fullH, px, py, pw, ph) {
const M = this.M;
const FPDFBitmap_BGRA = 4;
const bmp = M._FPDFBitmap_CreateEx(pw, ph, FPDFBitmap_BGRA, 0, 0);
if (!bmp) return null;
M._FPDFBitmap_FillRect(bmp, 0, 0, pw, ph, 0xffffffff);
const FPDF_ANNOT = 0x01,
FPDF_LCD_TEXT = 0x02,
FPDF_REVERSE_BYTE_ORDER = 0x10;
const FLAGS = FPDF_ANNOT | FPDF_LCD_TEXT | FPDF_REVERSE_BYTE_ORDER;
M._FPDF_RenderPageBitmap(bmp, this.page, -px, -py, fullW, fullH, 0, FLAGS);
M._ec_form_draw(
this.session,
this.page,
bmp,
-px,
-py,
fullW,
fullH,
0,
FLAGS
);
const buf = M._FPDFBitmap_GetBuffer(bmp);
const stride = M._FPDFBitmap_GetStride(bmp);
const out = new Uint8ClampedArray(pw * ph * 4);
if (stride === pw * 4) {
out.set(M.HEAPU8.subarray(buf, buf + pw * ph * 4));
} else {
for (let y = 0; y < ph; y++) {
out.set(
M.HEAPU8.subarray(buf + y * stride, buf + y * stride + pw * 4),
y * pw * 4
);
}
}
M._FPDFBitmap_Destroy(bmp);
return { width: pw, height: ph, data: out };
}
addParagraph(x, yTop, width, runs, fmt) {
this._pageDirty = true;
const a = this._writeRuns(runs);
const f = this._writeFmt(fmt);
const out = this._decode(
this.M._ec_add_paragraph(
this.session,
this.page,
x,
yTop,
width,
a.arr,
a.count,
f
)
);
this._free(a);
this.M._free(f);
return out;
}
synthRunFont(paraId, runIndex) {
const M = this.M;
const sp = M._malloc(4);
M.HEAPU32[sp >> 2] = 0;
const ptr = M._ec_synth_run_font(
this.session,
this.page,
paraId,
runIndex,
sp
);
const size = M.HEAPU32[sp >> 2];
M._free(sp);
if (!ptr || !size) return null;
if (size === 1) {
const flag = M.HEAPU8[ptr];
M._ec_string_free(ptr);
return flag === 0xdd ? 'dishonest' : null;
}
const bytes = M.HEAPU8.slice(ptr, ptr + size);
M._ec_string_free(ptr);
return bytes;
}
duplicateParagraph(id, dx, dy) {
this._pageDirty = true;
return this._decode(
this.M._ec_duplicate_paragraph(this.session, this.page, id, dx, dy)
);
}
cloneMarker(srcId, dstId) {
this._pageDirty = true;
return this.M._ec_clone_marker(this.session, this.page, srcId, dstId) !== 0;
}
moveParagraph(id, dx, dy) {
this._pageDirty = true;
return this.M._ec_move_paragraph(this.session, this.page, id, dx, dy) !== 0;
}
resizeParagraph(id, width) {
this._pageDirty = true;
return this._decode(
this.M._ec_resize_paragraph(this.session, this.page, id, width)
);
}
historyBeginStep(label) {
const M = this.M;
const lbl = this._allocStr(label || 'edit');
M._ec_history_begin(this.session, this.page, lbl);
M._free(lbl);
}
historyEndStep() {
const before = this.M._ec_history_depth(this.session, 0);
this.M._ec_history_end(this.session, this.page);
if (this._spliceOk === false) return;
if (this.M._ec_history_depth(this.session, 0) <= before) return;
const plan = this.lastSplicePlan();
if (plan) (this._splicePlans ||= []).push({ page: this.pageIndex, plan });
else this._spliceOk = false;
}
lastSplicePlan() {
const ptr = this.M._ec_last_splice_plan(this.session, this.page);
if (!ptr) return null;
const json = this.M.UTF8ToString(ptr);
this.M._ec_string_free(ptr);
try {
return JSON.parse(json);
} catch {
return null;
}
}
editStep(label, fn) {
this.historyBeginStep(label);
try {
return fn();
} finally {
this.historyEndStep();
}
}
historyNoteMatrix(handle) {
this.M._ec_history_note_matrix(this.session, this.page, handle);
}
historyNoteZOrder(handle) {
this.M._ec_history_note_zorder(this.session, this.page, handle);
}
historyNoteInsert(handle) {
this.M._ec_history_note_insert(this.session, this.page, handle);
}
historyRemoveObject(handle) {
this._pageDirty = true;
return (
this.M._ec_history_remove_object(this.session, this.page, handle) !== 0
);
}
historyUndo() {
this._pageDirty = true;
const ok = this.M._ec_history_undo(this.session, this.page) !== 0;
if (ok && this._splicePlans?.length) {
const last = this._splicePlans[this._splicePlans.length - 1];
if (last.page === this.pageIndex) this._splicePlans.pop();
else this._spliceOk = false;
}
return ok;
}
historyRedo() {
this._pageDirty = true;
const ok = this.M._ec_history_redo(this.session, this.page) !== 0;
if (ok && this._spliceOk !== false) {
const plan = this.lastSplicePlan();
if (plan) (this._splicePlans ||= []).push({ page: this.pageIndex, plan });
else this._spliceOk = false;
}
return ok;
}
historyDepth() {
return {
undo: this.M._ec_history_depth(this.session, 0),
redo: this.M._ec_history_depth(this.session, 1),
};
}
historyClear() {
this.M._ec_history_clear(this.session);
}
spellLoad(bytes) {
const M = this.M;
const buf = M._malloc(bytes.length);
M.HEAPU8.set(bytes, buf);
const n = M._ec_spell_load(this.session, buf, bytes.length);
M._free(buf);
return n;
}
spellCheckPage() {
const M = this.M;
const ptr = M._ec_spell_check_page(this.session, this.page);
if (!ptr) return null;
const json = M.UTF8ToString(ptr);
M._ec_string_free(ptr);
try {
return JSON.parse(json);
} catch {
return null;
}
}
selectText(x0, y0, x1, y1, mode) {
const M = this.M;
const ptr = M._ec_select_text(
this.session,
this.page,
x0,
y0,
x1,
y1,
mode | 0
);
if (!ptr) return null;
const json = M.UTF8ToString(ptr);
M._ec_string_free(ptr);
try {
return JSON.parse(json);
} catch {
return null;
}
}
pageTextJson() {
const M = this.M;
const ptr = M._ec_page_text_json(this.session, this.page);
if (!ptr) return null;
const json = M.UTF8ToString(ptr);
M._ec_string_free(ptr);
try {
return JSON.parse(json);
} catch {
return null;
}
}
buildModelInRegion(x, y, w, h) {
const M = this.M;
const ptr = M._ec_build_page_model_region(
this.session,
this.page,
x,
y,
w,
h
);
if (!ptr) return [];
const json = M.UTF8ToString(ptr);
M._ec_string_free(ptr);
try {
return JSON.parse(json).paragraphs || [];
} catch {
return [];
}
}
deleteParagraph(id) {
this._pageDirty = true;
return this.M._ec_delete_paragraph(this.session, this.page, id) !== 0;
}
runFontData(paraId, runIndex) {
const M = this.M;
const needed = M._ec_get_run_font_data(
this.session,
this.page,
paraId,
runIndex,
0,
0
);
if (!needed) return null;
const buf = M._malloc(needed);
const written = M._ec_get_run_font_data(
this.session,
this.page,
paraId,
runIndex,
buf,
needed
);
const out =
written > 0
? M.HEAPU8.slice(buf, buf + Math.min(needed, written || needed))
: null;
M._free(buf);
return out && out.length ? out : null;
}
paragraphObjects(id) {
const M = this.M;
const total = M._ec_get_paragraph_objects(
this.session,
this.page,
id,
0,
0
);
if (total <= 0) return [];
const out = M._malloc(total * 4);
M._ec_get_paragraph_objects(this.session, this.page, id, out, total);
const handles = [];
for (let i = 0; i < total; i++) handles.push(M.HEAPU32[(out >> 2) + i]);
M._free(out);
return handles;
}
objectCount() {
return this.M._FPDFPage_CountObjects(this.page);
}
objectAt(index) {
const M = this.M;
const h = M._FPDFPage_GetObject(this.page, index);
if (!h) return null;
return { handle: h, index, type: M._FPDFPageObj_GetType(h) };
}
objectBounds(handle) {
const b = this._rawBounds(handle);
if (!b) return null;
const p0 = this.toModel(b.x, b.y);
const p1 = this.toModel(b.x + b.w, b.y + b.h);
return {
...b,
x: Math.min(p0.x, p1.x),
y: Math.min(p0.y, p1.y),
w: Math.abs(p1.x - p0.x),
h: Math.abs(p1.y - p0.y),
};
}
_rawBounds(handle) {
const M = this.M;
const p = M._malloc(16);
const ok = M._FPDFPageObj_GetBounds(handle, p, p + 4, p + 8, p + 12);
const l = M.HEAPF32[p >> 2],
b = M.HEAPF32[(p + 4) >> 2];
const r = M.HEAPF32[(p + 8) >> 2],
t = M.HEAPF32[(p + 12) >> 2];
M._free(p);
if (!ok) return null;
return { x: l, y: b, w: r - l, h: t - b };
}
deltaToUser(dx, dy) {
const t = this.pageT || [1, 0, 0, 1, 0, 0];
const det = t[0] * t[3] - t[1] * t[2] || 1;
return {
x: (t[3] * dx - t[2] * dy) / det,
y: (-t[1] * dx + t[0] * dy) / det,
};
}
translateObject(handle, dx, dy) {
this._pageDirty = true;
({ x: dx, y: dy } = this.deltaToUser(dx, dy));
const M = this.M;
const m = M._malloc(24);
M.HEAPF32[(m + 0) >> 2] = 1;
M.HEAPF32[(m + 4) >> 2] = 0;
M.HEAPF32[(m + 8) >> 2] = 0;
M.HEAPF32[(m + 12) >> 2] = 1;
M.HEAPF32[(m + 16) >> 2] = dx;
M.HEAPF32[(m + 20) >> 2] = dy;
M._FPDFPageObj_TransformClipPath(handle, 1, 0, 0, 1, dx, dy);
M._FPDFPageObj_TransformF(handle, m);
M._free(m);
}
transformObjectAboutCenter(handle, a, b, c, d) {
this._pageDirty = true;
const M = this.M;
const bounds = this._rawBounds(handle);
if (!bounds) return;
const cx = bounds.x + bounds.w / 2,
cy = bounds.y + bounds.h / 2;
const e = cx - a * cx - c * cy;
const f = cy - b * cx - d * cy;
const m = M._malloc(24);
M.HEAPF32[(m + 0) >> 2] = a;
M.HEAPF32[(m + 4) >> 2] = b;
M.HEAPF32[(m + 8) >> 2] = c;
M.HEAPF32[(m + 12) >> 2] = d;
M.HEAPF32[(m + 16) >> 2] = e;
M.HEAPF32[(m + 20) >> 2] = f;
M._FPDFPageObj_TransformClipPath(handle, a, b, c, d, e, f);
M._FPDFPageObj_TransformF(handle, m);
M._free(m);
}
rotateObject(handle, deg) {
this._pageDirty = true;
const r = (deg * Math.PI) / 180;
this.transformObjectAboutCenter(
handle,
Math.cos(r),
Math.sin(r),
-Math.sin(r),
Math.cos(r)
);
}
rotateObjectsAbout(handles, deg, cx, cy) {
({ x: cx, y: cy } = this.toUser(cx, cy));
this._pageDirty = true;
const M = this.M;
const r = (deg * Math.PI) / 180,
c = Math.cos(r),
s = Math.sin(r);
const m = M._malloc(24);
M.HEAPF32[(m + 0) >> 2] = c;
M.HEAPF32[(m + 4) >> 2] = s;
M.HEAPF32[(m + 8) >> 2] = -s;
M.HEAPF32[(m + 12) >> 2] = c;
M.HEAPF32[(m + 16) >> 2] = cx - c * cx + s * cy;
M.HEAPF32[(m + 20) >> 2] = cy - s * cx - c * cy;
for (const h of handles) {
M._FPDFPageObj_TransformClipPath(
h,
c,
s,
-s,
c,
cx - c * cx + s * cy,
cy - s * cx - c * cy
);
M._FPDFPageObj_TransformF(h, m);
}
M._free(m);
}
flipObject(handle, horizontal) {
this._pageDirty = true;
this.transformObjectAboutCenter(
handle,
horizontal ? -1 : 1,
0,
0,
horizontal ? 1 : -1
);
}
replaceImage(handle, bgra, width, height) {
this._pageDirty = true;
const M = this.M;
const buf = M._malloc(bgra.length);
M.HEAPU8.set(bgra, buf);
const bmp = M._FPDFBitmap_CreateEx(width, height, 4, buf, width * 4);
let ok = false;
if (bmp) {
const pages = M._malloc(4);
M.HEAP32[pages >> 2] = this.page;
ok = !!M._FPDFImageObj_SetBitmap(pages, 1, handle, bmp);
M._free(pages);
M._FPDFBitmap_Destroy(bmp);
}
M._free(buf);
return ok;
}
renderImageObject(handle) {
const M = this.M;
const bmp = M._FPDFImageObj_GetRenderedBitmap(this.doc, this.page, handle);
if (!bmp) return null;
const w = M._FPDFBitmap_GetWidth(bmp),
h = M._FPDFBitmap_GetHeight(bmp);
const stride = M._FPDFBitmap_GetStride(bmp);
const buf = M._FPDFBitmap_GetBuffer(bmp);
const out = new Uint8ClampedArray(w * h * 4);
for (let y = 0; y < h; y++) {
for (let x = 0; x < w; x++) {
const si = buf + y * stride + x * 4,
di = (y * w + x) * 4;
out[di] = M.HEAPU8[si + 2];
out[di + 1] = M.HEAPU8[si + 1];
out[di + 2] = M.HEAPU8[si];
out[di + 3] = M.HEAPU8[si + 3];
}
}
M._FPDFBitmap_Destroy(bmp);
return { data: out, width: w, height: h };
}
untaggedMarks() {
const M = this.M;
const tree = M._FPDF_StructTree_GetForPage(this.page);
if (!tree) return [];
const registered = new Set();
const walk = (el) => {
const id = M._FPDF_StructElement_GetMarkedContentID(el);
if (id >= 0) registered.add(id);
const n = M._FPDF_StructElement_CountChildren(el);
for (let i = 0; i < n; i++) {
const ch = M._FPDF_StructElement_GetChildAtIndex(el, i);
if (ch) walk(ch);
}
};
const n = M._FPDF_StructTree_CountChildren(tree);
for (let i = 0; i < n; i++)
walk(M._FPDF_StructTree_GetChildAtIndex(tree, i));
M._FPDF_StructTree_Close(tree);
const out = new Map();
const key = M._malloc(8);
M.stringToUTF8('MCID', key, 8);
const val = M._malloc(4);
for (let i = 0; i < this.objectCount(); i++) {
const o = this.objectAt(i);
if (!o) continue;
const nm = M._FPDFPageObj_CountMarks(o.handle);
for (let k = 0; k < nm; k++) {
const mk = M._FPDFPageObj_GetMark(o.handle, k);
if (!mk) continue;
const nb = M._malloc(32),
need = M._malloc(4);
let name = '';
if (M._FPDFPageObjMark_GetName(mk, nb, 32, need)) {
const len = M.HEAPU32[need >> 2];
for (let q = 0; q + 2 <= len; q += 2) {
const c = M.HEAPU8[nb + q] | (M.HEAPU8[nb + q + 1] << 8);
if (c) name += String.fromCharCode(c);
}
}
M._free(nb);
M._free(need);
if (name !== 'P' && name !== 'Figure') continue;
if (!M._FPDFPageObjMark_GetParamIntValue(mk, key, val)) continue;
const mcid = M.HEAP32[val >> 2];
if (mcid >= 0 && !registered.has(mcid))
out.set(mcid, { mcid, type: name });
}
}
M._free(key);
M._free(val);
return [...out.values()].sort((a, b) => a.mcid - b.mcid);
}
objectMcid(handle) {
const M = this.M;
const key = M._malloc(8);
M.stringToUTF8('MCID', key, 8);
const val = M._malloc(4);
let mcid = -1;
const nm = M._FPDFPageObj_CountMarks(handle);
for (let k = 0; k < nm && mcid < 0; k++) {
const mk = M._FPDFPageObj_GetMark(handle, k);
if (mk && M._FPDFPageObjMark_GetParamIntValue(mk, key, val)) {
mcid = M.HEAP32[val >> 2];
}
}
M._free(key);
M._free(val);
return mcid;
}
tagObject(handle, name) {
this._pageDirty = true;
const M = this.M;
let maxM = -1;
for (let i = 0; i < this.objectCount(); i++) {
const o = this.objectAt(i);
if (o) maxM = Math.max(maxM, this.objectMcid(o.handle));
}
const nbuf = M._malloc(name.length + 1);
M.stringToUTF8(name, nbuf, name.length + 1);
const mk = M._FPDFPageObj_AddMark(handle, nbuf);
let ok = false;
if (mk) {
const key = M._malloc(8);
M.stringToUTF8('MCID', key, 8);
ok = !!M._FPDFPageObjMark_SetIntParam(
this.doc,
handle,
mk,
key,
maxM + 1
);
M._free(key);
}
M._free(nbuf);
return ok;
}
pageIsTagged() {
const M = this.M;
const tree = M._FPDF_StructTree_GetForPage(this.page);
if (!tree) return false;
const n = M._FPDF_StructTree_CountChildren(tree);
M._FPDF_StructTree_Close(tree);
return n > 0;
}
structAltFor(mcid) {
const M = this.M;
const tree = M._FPDF_StructTree_GetForPage(this.page);
if (!tree) return null;
let found = null;
const walk = (el) => {
if (found !== null) return;
if (M._FPDF_StructElement_GetMarkedContentID(el) === mcid) {
const need = M._FPDF_StructElement_GetAltText(el, 0, 0);
let txt = '';
if (need > 2) {
const buf = M._malloc(need);
M._FPDF_StructElement_GetAltText(el, buf, need);
for (let q = 0; q + 2 <= need - 2; q += 2) {
const c = M.HEAPU8[buf + q] | (M.HEAPU8[buf + q + 1] << 8);
if (c) txt += String.fromCharCode(c);
}
M._free(buf);
}
found = txt;
return;
}
const n = M._FPDF_StructElement_CountChildren(el);
for (let i = 0; i < n; i++) {
const ch = M._FPDF_StructElement_GetChildAtIndex(el, i);
if (ch) walk(ch);
}
};
const n = M._FPDF_StructTree_CountChildren(tree);
for (let i = 0; i < n; i++)
walk(M._FPDF_StructTree_GetChildAtIndex(tree, i));
M._FPDF_StructTree_Close(tree);
return found;
}
collectShadings() {
const out = [];
let firstOther = -1;
for (let i = 0; i < this.objectCount(); i++) {
const o = this.objectAt(i);
if (!o) continue;
if (o.type === 4) out.push({ index: i });
else if (firstOther < 0) firstOther = i;
}
return out.map((s2) => ({
...s2,
isBackground: firstOther < 0 || s2.index < firstOther,
}));
}
pathStyle(handle) {
const M = this.M;
const p = M._malloc(24);
const st = { stroke: false, strokeRgba: 0, strokeWidth: 1, fill: false };
if (M._FPDFPath_GetDrawMode(handle, p, p + 4)) {
st.fill = M.HEAP32[p >> 2] !== 0;
st.stroke = M.HEAP32[(p + 4) >> 2] !== 0;
}
if (M._FPDFPageObj_GetStrokeColor(handle, p, p + 4, p + 8, p + 12)) {
st.strokeRgba =
(((M.HEAPU32[p >> 2] & 0xff) << 24) |
((M.HEAPU32[(p + 4) >> 2] & 0xff) << 16) |
((M.HEAPU32[(p + 8) >> 2] & 0xff) << 8) |
(M.HEAPU32[(p + 12) >> 2] & 0xff)) >>>
0;
}
if (M._FPDFPageObj_GetStrokeWidth(handle, p)) {
st.strokeWidth = M.HEAPF32[p >> 2];
}
M._free(p);
return st;
}
setPathStroke(handle, rgba, width) {
this._pageDirty = true;
const M = this.M;
const p = M._malloc(8);
let fill = 0;
if (M._FPDFPath_GetDrawMode(handle, p, p + 4)) fill = M.HEAP32[p >> 2];
M._free(p);
M._FPDFPageObj_SetStrokeColor(
handle,
(rgba >>> 24) & 0xff,
(rgba >>> 16) & 0xff,
(rgba >>> 8) & 0xff,
rgba & 0xff
);
M._FPDFPageObj_SetStrokeWidth(handle, width > 0 ? width : 1);
M._FPDFPath_SetDrawMode(handle, fill, 1);
}
removeObject(handle) {
this._pageDirty = true;
if (this.M._FPDFPage_RemoveObject(this.page, handle)) {
this.M._FPDFPageObj_Destroy(handle);
return true;
}
return false;
}
scaleObject(handle, sx, sy, anchorX, anchorY) {
({ x: anchorX, y: anchorY } = this.toUser(anchorX, anchorY));
if (this.pageT && Math.abs(this.pageT[0]) < 0.5) {
const t2 = sx;
sx = sy;
sy = t2;
}
this._pageDirty = true;
const M = this.M;
const m = M._malloc(24);
M.HEAPF32[(m + 0) >> 2] = sx;
M.HEAPF32[(m + 4) >> 2] = 0;
M.HEAPF32[(m + 8) >> 2] = 0;
M.HEAPF32[(m + 12) >> 2] = sy;
M.HEAPF32[(m + 16) >> 2] = anchorX - sx * anchorX;
M.HEAPF32[(m + 20) >> 2] = anchorY - sy * anchorY;
M._FPDFPageObj_TransformClipPath(
handle,
sx,
0,
0,
sy,
anchorX - sx * anchorX,
anchorY - sy * anchorY
);
M._FPDFPageObj_TransformF(handle, m);
M._free(m);
}
currentIndexOf(handle) {
for (let i = 0; i < this.objectCount(); i++)
if (this.M._FPDFPage_GetObject(this.page, i) === handle) return i;
return -1;
}
arrangeObject(handle, op) {
this._pageDirty = true;
const M = this.M;
const idx = this.currentIndexOf(handle);
if (idx < 0) return false;
const last = this.objectCount() - 1;
const target =
op === 'front'
? last
: op === 'back'
? 0
: op === 'forward'
? Math.min(last, idx + 1)
: Math.max(0, idx - 1);
if (target === idx) return false;
if (!M._FPDFPage_RemoveObject(this.page, handle)) return false;
if (!M._FPDFPage_InsertObjectAtIndex(this.page, handle, target))
M._FPDFPage_InsertObject(this.page, handle);
return true;
}
insertImage(rgba, pxW, pxH, x, y, w, h) {
this._pageDirty = true;
const M = this.M;
const handle = M._FPDFPageObj_NewImageObj(this.doc);
if (!handle) return 0;
const FPDFBitmap_BGRA = 4;
const bmp = M._FPDFBitmap_Create(pxW, pxH, 1);
const buf = M._FPDFBitmap_GetBuffer(bmp);
const stride = M._FPDFBitmap_GetStride(bmp);
for (let row = 0; row < pxH; row++) {
let src = row * pxW * 4,
dst = buf + row * stride;
for (let col = 0; col < pxW; col++) {
M.HEAPU8[dst] = rgba[src + 2];
M.HEAPU8[dst + 1] = rgba[src + 1];
M.HEAPU8[dst + 2] = rgba[src];
M.HEAPU8[dst + 3] = rgba[src + 3];
src += 4;
dst += 4;
}
}
const pagesPtr = M._malloc(4);
M.HEAPU32[pagesPtr >> 2] = this.page;
M._FPDFImageObj_SetBitmap(pagesPtr, 1, handle, bmp);
M._free(pagesPtr);
M._FPDFBitmap_Destroy(bmp);
const m = M._malloc(24);
M.HEAPF32[(m + 0) >> 2] = w;
M.HEAPF32[(m + 4) >> 2] = 0;
M.HEAPF32[(m + 8) >> 2] = 0;
M.HEAPF32[(m + 12) >> 2] = h;
const at = this.toUser(x, y);
M.HEAPF32[(m + 16) >> 2] = at.x;
M.HEAPF32[(m + 20) >> 2] = at.y;
M._FPDFPageObj_SetMatrix(handle, m);
M._free(m);
M._FPDFPage_InsertObject(this.page, handle);
return handle;
}
duplicateImage(handle, dx, dy) {
this._pageDirty = true;
const M = this.M;
const b = this.objectBounds(handle);
if (!b) return 0;
const sz = M._malloc(8);
let iw = 0,
ih = 0;
if (M._FPDFImageObj_GetImagePixelSize(handle, sz, sz + 4)) {
iw = M.HEAPU32[sz >> 2];
ih = M.HEAPU32[(sz + 4) >> 2];
}
M._free(sz);
const mp = M._malloc(24);
let saved = null;
if (M._FPDFPageObj_GetMatrix(handle, mp)) {
saved = [0, 1, 2, 3, 4, 5].map((i) => M.HEAPF32[(mp >> 2) + i]);
}
const upright =
saved && saved[1] === 0 && saved[2] === 0 && saved[0] > 0 && saved[3] > 0;
let boosted = false;
if (upright && iw > 0 && ih > 0 && (iw > saved[0] || ih > saved[3])) {
const s = Math.min(1, 4096 / Math.max(iw, ih));
M.HEAPF32.set([iw * s, 0, 0, ih * s, saved[4], saved[5]], mp >> 2);
M._FPDFPageObj_SetMatrix(handle, mp);
boosted = true;
}
const bmp = M._FPDFImageObj_GetRenderedBitmap(this.doc, this.page, handle);
if (boosted) {
M.HEAPF32.set(saved, mp >> 2);
M._FPDFPageObj_SetMatrix(handle, mp);
}
M._free(mp);
if (!bmp) return 0;
const w = M._FPDFBitmap_GetWidth(bmp),
h = M._FPDFBitmap_GetHeight(bmp);
const stride = M._FPDFBitmap_GetStride(bmp),
buf = M._FPDFBitmap_GetBuffer(bmp);
const rgba = new Uint8Array(w * h * 4);
for (let row = 0; row < h; row++) {
let src = buf + row * stride,
dst = row * w * 4;
for (let col = 0; col < w; col++) {
rgba[dst] = M.HEAPU8[src + 2];
rgba[dst + 1] = M.HEAPU8[src + 1];
rgba[dst + 2] = M.HEAPU8[src];
rgba[dst + 3] = M.HEAPU8[src + 3];
src += 4;
dst += 4;
}
}
M._FPDFBitmap_Destroy(bmp);
return this.insertImage(rgba, w, h, b.x + dx, b.y + dy, b.w, b.h);
}
objectFill(handle) {
const M = this.M;
const p = M._malloc(16);
const ok = M._FPDFPageObj_GetFillColor(handle, p, p + 4, p + 8, p + 12);
const r = M.HEAPU32[p >> 2],
g = M.HEAPU32[(p + 4) >> 2];
const b = M.HEAPU32[(p + 8) >> 2],
a = M.HEAPU32[(p + 12) >> 2];
M._free(p);
return ok ? { r, g, b, a } : null;
}
setObjectFill(handle, r, g, b, a) {
this._pageDirty = true;
this.M._FPDFPageObj_SetFillColor(handle, r, g, b, a);
}
renderPage(scale, hideHandles = null) {
const M = this.M;
const s = Math.min(
scale,
4096 / Math.max(1, this.pageWidth),
4096 / Math.max(1, this.pageHeight)
);
scale = Math.max(0.05, s);
const w = Math.max(1, Math.round(this.pageWidth * scale));
const h = Math.max(1, Math.round(this.pageHeight * scale));
let saved = null,
mp = 0;
if (hideHandles && hideHandles.length) {
mp = M._malloc(24);
saved = [];
for (const handle of hideHandles) {
if (!M._FPDFPageObj_GetMatrix(handle, mp)) continue;
saved.push([handle, M.HEAPF32.slice(mp >> 2, (mp >> 2) + 6)]);
M.HEAPF32[(mp + 0) >> 2] = 1e-6;
M.HEAPF32[(mp + 4) >> 2] = 0;
M.HEAPF32[(mp + 8) >> 2] = 0;
M.HEAPF32[(mp + 12) >> 2] = 1e-6;
M.HEAPF32[(mp + 16) >> 2] = -1e6;
M.HEAPF32[(mp + 20) >> 2] = -1e6;
M._FPDFPageObj_SetMatrix(handle, mp);
}
}
const FPDFBitmap_BGRA = 4;
const bmp = M._FPDFBitmap_CreateEx(w, h, FPDFBitmap_BGRA, 0, 0);
M._FPDFBitmap_FillRect(bmp, 0, 0, w, h, 0xffffffff);
const FPDF_ANNOT = 0x01,
FPDF_LCD_TEXT = 0x02,
FPDF_REVERSE_BYTE_ORDER = 0x10;
const FLAGS = FPDF_ANNOT | FPDF_LCD_TEXT | FPDF_REVERSE_BYTE_ORDER;
M._FPDF_RenderPageBitmap(bmp, this.page, 0, 0, w, h, 0, FLAGS);
M._ec_form_draw(this.session, this.page, bmp, 0, 0, w, h, 0, FLAGS);
if (saved) {
for (const [handle, m] of saved) {
M.HEAPF32.set(m, mp >> 2);
M._FPDFPageObj_SetMatrix(handle, mp);
}
M._free(mp);
}
const buf = M._FPDFBitmap_GetBuffer(bmp);
const stride = M._FPDFBitmap_GetStride(bmp);
const out = new Uint8ClampedArray(w * h * 4);
if (stride === w * 4) {
out.set(M.HEAPU8.subarray(buf, buf + w * h * 4));
} else {
for (let y = 0; y < h; y++) {
out.set(
M.HEAPU8.subarray(buf + y * stride, buf + y * stride + w * 4),
y * w * 4
);
}
}
M._FPDFBitmap_Destroy(bmp);
return { width: w, height: h, data: out };
}
generateContent() {
if (!this._pageDirty) return true;
if (this._t3seg && this._t3seg[this.pageIndex]) {
const st = this._t3readState();
if (st) {
this._t3anchor(st);
(this._t3state ||= {})[this.pageIndex] = st.filter(
(o) => o.t3 && !o.inForm && o.glyphs && o.glyphs.length
);
}
}
if (this.session) this.M._ec_dealias_page_fonts(this.session, this.page);
this.M._ec_normalize_page_paint(this.page);
const ok = this.M._FPDFPage_GenerateContent(this.page) !== 0;
if (ok) this._spliceOk = false;
if (ok && this._usesPattern) this._pageStale = true;
if (ok) {
this._pageDirty = false;
(this._editedPages ||= new Set()).add(this.pageIndex);
}
return ok;
}
async saveSpliced(opts) {
if (
this._spliceOk === false ||
!this._splicePlans?.length ||
!this._originalBytes ||
this._reencoded?.size ||
this._normalizedBytes
)
return this.save(opts);
try {
const { applyPlan } = await import('./streamsplice.js');
const writeCount = this._splicePlans.filter(
(e) => e.plan?.kind === 'write'
).length;
if (writeCount > 1) return this.save(opts);
let bytes = this._originalBytes;
for (const { page, plan } of this._splicePlans) {
const next = await applyPlan(bytes, page, plan);
if (!next) return this.save(opts);
bytes = next;
}
return bytes;
} catch {
return this.save(opts);
}
}
renderParagraphLiveEnd() {
if (this.M._ec_render_paragraph_live_end && this.session && this.page) {
this.M._ec_render_paragraph_live_end(this.session, this.page);
}
}
save(opts) {
this.renderParagraphLiveEnd();
if (this._pageDirty && !opts?.noRegen) this.generateContent();
const M = this.M;
const sizePtr = M._malloc(4);
const hasT3 = this._t3seg && Object.keys(this._t3seg).length > 0;
const incremental = (opts && opts.incremental) || hasT3;
const outPtr = M._ec_save_document(this.doc, incremental ? 1 : 2, sizePtr);
const size = M.HEAPU32[sizePtr >> 2];
M._free(sizePtr);
if (!outPtr || !size) return null;
let bytes = M.HEAPU8.slice(outPtr, outPtr + size);
M._ec_string_free(outPtr);
if (hasT3 && this._t3state) {
try {
const jobs = Object.entries(this._t3state).map(([pi, state]) => ({
pageIndex: Number(pi),
seg: this._t3seg[pi],
state,
anchors: this._t3anchors?.[pi] || {},
}));
const fixed = applyType3LeftoverSurgery(bytes, jobs);
if (fixed) {
bytes = fixed.bytes;
for (const [pi, tjEntries] of Object.entries(fixed.injected)) {
this._t3seg[pi]?.tjs?.push(...tjEntries);
}
}
} catch (e) {
console.warn('type3 surgery skipped:', e);
}
}
return bytes;
}
}
Reference in New Issue View Git Blame Copy Permalink