@file-viewer/renderer-ofd 3.0.2 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/renderer-ofd",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "private": false,
   "type": "module",
   "description": "Standalone OFD renderer plugin for File Viewer powered by DLTech21/ofd.js.",
@@ -54,10 +54,11 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@file-viewer/core": "3.0.2",
-    "jszip": "^3.10.1"
+    "@file-viewer/core": "3.1.0",
+    "jszip": "3.10.2"
   },
   "devDependencies": {
+    "@xmldom/xmldom": "0.9.12",
     "linkedom": "^0.18.12",
     "typescript": "^6.0.3"
   },
@@ -72,6 +73,7 @@
     "verify:image-placement": "node scripts/verify-image-placement.mjs",
     "verify:pageblock-render": "node scripts/verify-pageblock-render.mjs",
     "verify:render-fidelity": "node scripts/verify-render-fidelity.mjs",
-    "verify:github-177": "pnpm --filter @file-viewer/core build && pnpm exec tsc -b tsconfig.json --force && node scripts/verify-github-177.mjs"
+    "verify:github-177": "pnpm --filter @file-viewer/core build && pnpm exec tsc -b tsconfig.json --force && node scripts/verify-github-177.mjs",
+    "verify:github-266": "node scripts/verify-github-266.mjs"
   }
 }

package/vendor/dltech/ofd/ofd_parser.js

@@ -43,6 +43,12 @@ const appendChildValue = function (target, key, value) {
     target[key] = value;
 }
 
+const xmlElementName = function (element) {
+    return element.namespaceURI === 'http://www.ofdspec.org/2016'
+        ? `ofd:${element.localName}`
+        : element.nodeName;
+}
+
 const parseXmlElement = function (element, options, order) {
     const attrPrefix = options.attributeNamePrefix ?? '@_';
     const result = {};
@@ -64,7 +70,7 @@ const parseXmlElement = function (element, options, order) {
             if (parsedChild && typeof parsedChild === 'object' && pfIndex !== undefined) {
                 parsedChild.pfIndex = pfIndex;
             }
-            appendChildValue(result, child.nodeName, parsedChild);
+            appendChildValue(result, xmlElementName(child), parsedChild);
             continue;
         }
         if (child.nodeType === 3 || child.nodeType === 4) {
@@ -72,7 +78,10 @@ const parseXmlElement = function (element, options, order) {
         }
     }
 
-    const text = textParts.join('').trim();
+    // TextCode whitespace consumes explicitly positioned glyph slots. Trimming
+    // it moves right-aligned dates and also shifts their DeltaX indices.
+    const rawText = textParts.join('');
+    const text = xmlElementName(element) === 'ofd:TextCode' ? rawText : rawText.trim();
     if (text) {
         if (Object.keys(result).length === 0) {
             return text;
@@ -103,7 +112,7 @@ const parseXmlToJson = function (xmlData, options = {}) {
         return {};
     }
     return {
-        [root.nodeName]: parseXmlElement(root, options, { next: 0 })
+        [xmlElementName(root)]: parseXmlElement(root, options, { next: 0 })
     };
 }
 
@@ -159,18 +168,13 @@ const joinZipPath = function (...parts) {
 }
 
 const startsWithZipRoot = function (path, root) {
-    const normalizedPath = normalizeZipPath(path);
-    const normalizedRoot = normalizeZipPath(root);
+    const normalizedPath = normalizeZipPath(path).toLowerCase();
+    const normalizedRoot = normalizeZipPath(root).toLowerCase();
     return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
 }
 
 const getZipEntry = function (zip, candidates) {
     const paths = asArray(candidates).map(normalizeZipPath).filter(Boolean);
-    for (const path of paths) {
-        if (zip.files[path]) {
-            return zip.files[path];
-        }
-    }
     let lowerMap = zipEntryMapCache.get(zip);
     if (!lowerMap) {
         lowerMap = new Map();
@@ -180,7 +184,7 @@ const getZipEntry = function (zip, candidates) {
         zipEntryMapCache.set(zip, lowerMap);
     }
     for (const path of paths) {
-        const entry = lowerMap.get(path.toLowerCase());
+        const entry = zip.files[path] || lowerMap.get(path.toLowerCase());
         if (entry) {
             return entry;
         }
@@ -190,15 +194,22 @@ const getZipEntry = function (zip, candidates) {
 
 const resolveDocumentPath = function (path, doc) {
     const normalizedPath = normalizeZipPath(path);
-    if (!normalizedPath || startsWithZipRoot(normalizedPath, doc)) {
+    if (!normalizedPath || !doc || /^[\\/]/.test(String(path).trim()) || startsWithZipRoot(normalizedPath, doc)) {
         return normalizedPath;
     }
-    return joinZipPath(doc, normalizedPath);
+    return joinZipPath(doc, path);
 }
 
-const resolveResourceCandidates = function (file, baseLoc, doc) {
+const resolveResourceCandidates = function (file, baseLoc, doc, resourcePath) {
     const mediaFile = normalizeZipPath(file);
     const base = normalizeZipPath(baseLoc);
+    const rawFile = String(file || '').replace(/\\/g, '/').trim();
+    const rawBase = String(baseLoc || '').replace(/\\/g, '/').trim();
+    const resourceDirectory = normalizeZipPath(resourcePath).split('/').slice(0, -1).join('/');
+    const resourceBase = rawBase.startsWith('/') ? normalizeZipPath(rawBase) : joinZipPath(resourceDirectory, rawBase);
+    // Resolve relative components before normalizing '..'. Declared locations
+    // outrank compatibility fallbacks, including their case-insensitive matches.
+    const declaredPath = rawFile.startsWith('/') ? mediaFile : joinZipPath(resourceBase, rawFile);
     const candidates = [mediaFile];
 
     if (base && !startsWithZipRoot(mediaFile, base)) {
@@ -213,7 +224,7 @@ const resolveResourceCandidates = function (file, baseLoc, doc) {
         }
     }
 
-    return [...new Set(docCandidates.filter(Boolean))];
+    return [...new Set([declaredPath, ...docCandidates].filter(Boolean))];
 }
 
 const getImageMime = function (format) {
@@ -295,7 +306,7 @@ const sealImageMime = function (type) {
 export const doGetDocRoot = async function (zip, docbody) {
     let docRoot = docbody['ofd:DocRoot'];
     docRoot = normalizeZipPath(replaceFirstSlash(docRoot));
-    const doc = docRoot.split('/')[0];
+    const doc = docRoot.split('/').slice(0, -1).join('/');
     const signatures = docbody['ofd:Signatures'];
     const stampAnnot = await getSignature(zip, signatures, doc);
     let stampAnnotArray = {};
@@ -422,7 +433,7 @@ export const getDocumentRes = async function ([zip, doc, Document, stampAnnot, a
             const documentResObj = data['json']['ofd:Res'];
             fontResObj = await getFont(documentResObj);
             drawParamResObj = await getDrawParam(documentResObj);
-            multiMediaResObj = await getMultiMediaRes(zip, documentResObj, doc);
+            multiMediaResObj = await getMultiMediaRes(zip, documentResObj, doc, documentResPath);
         }
     }
     return [zip, doc, Document, stampAnnot, annotationObjs, fontResObj, drawParamResObj, multiMediaResObj];
@@ -439,7 +450,7 @@ export const getPublicRes = async function ([zip, doc, Document, stampAnnot, ann
             fontResObj = Object.assign(fontResObj, fontObj);
             let drawParamObj = await getDrawParam(publicResObj);
             drawParamResObj = Object.assign(drawParamResObj, drawParamObj);
-            let multiMediaObj = await getMultiMediaRes(zip, publicResObj, doc);
+            let multiMediaObj = await getMultiMediaRes(zip, publicResObj, doc, publicResPath);
             multiMediaResObj = Object.assign(multiMediaResObj, multiMediaObj);
         }
     }
@@ -529,14 +540,14 @@ const getDrawParam = async function (res) {
     return drawParamResObj;
 }
 
-const getMultiMediaRes = async function (zip, res, doc) {
+const getMultiMediaRes = async function (zip, res, doc, resourcePath) {
     const multiMedias = res['ofd:MultiMedias'];
     let multiMediaResObj = {};
     if (multiMedias) {
         let array = collectGroupedItems(multiMedias, 'ofd:MultiMedia');
         for (const item of array) {
             if (item && item['ofd:MediaFile']) {
-                const candidates = resolveResourceCandidates(item['ofd:MediaFile'], res['@_BaseLoc'], doc);
+                const candidates = resolveResourceCandidates(item['ofd:MediaFile'], res['@_BaseLoc'], doc, resourcePath);
                 const file = getZipEntry(zip, candidates) ? candidates : null;
                 const type = item['@_Type'] ? item['@_Type'].toLowerCase() : '';
                 if (type === 'image') {
@@ -643,6 +654,7 @@ const getSignatureData = async function (zip, signature, signatureID) {
         'signedInfo': {
             'signatureID': signatureID,
             'VerifyRet': sealObj.verifyRet,
+            'VerificationStatus': sealObj.verificationStatus || 'not-verified',
             'Provider': signedInfoNode['ofd:Provider'],
             'SignatureMethod': signedInfoNode['ofd:SignatureMethod'],
             'SignatureDateTime': signedInfoNode['ofd:SignatureDateTime'],
@@ -663,44 +675,32 @@ const getSealDocumentObj = function (stampAnnot) {
 }
 
 const getJsonFromXmlContent = async function (zip, xmlName) {
-    return new Promise((resolve, reject) => {
-        const entry = getZipEntry(zip, xmlName);
-        if (!entry) {
-            reject(new Error(`OFD XML resource not found: ${normalizeZipPath(xmlName)}`));
-            return;
-        }
-        entry.async('string').then(function (content) {
-            ensureBrowserGlobal();
-            let ops = {
-                attributeNamePrefix: "@_",
-                ignoreAttributes: false,
-                parseNodeValue: false,
-                trimValues: false
-            };
-            let jsonObj = parseXmlToJson(content, ops);
-            let result = {'xml': content, 'json': jsonObj};
-            resolve(result);
-        }, function error(e) {
-            reject(e);
-        })
-    });
+    const entry = getZipEntry(zip, xmlName);
+    if (!entry) {
+        throw new Error(`OFD XML resource not found: ${normalizeZipPath(xmlName)}`);
+    }
+    const content = await entry.async('string');
+    ensureBrowserGlobal();
+    try {
+        const json = parseXmlToJson(content, {
+            attributeNamePrefix: "@_",
+            ignoreAttributes: false,
+            parseNodeValue: false,
+            trimValues: false
+        });
+        return {xml: content, json};
+    } catch (error) {
+        throw new Error(`OFD XML parse failed (${normalizeZipPath(xmlName)}): ${error.message}`);
+    }
 }
 
 const parseJbig2ImageFromZip = async function (zip, name) {
-    return new Promise((resolve, reject) => {
-        const entry = getZipEntry(zip, name);
-        if (!entry) {
-            resolve(null);
-            return;
-        }
-        entry.async('uint8array').then(function (bytes) {
-            let jbig2 = new Jbig2Image();
-            const img = jbig2.parse(bytes);
-            resolve({img, width: jbig2.width, height: jbig2.height, format: 'gbig2'});
-        }, function error(e) {
-            reject(e);
-        })
-    });
+    const entry = getZipEntry(zip, name);
+    if (!entry) return null;
+    const bytes = await entry.async('uint8array');
+    const jbig2 = new Jbig2Image();
+    const img = jbig2.parse(bytes);
+    return {img, width: jbig2.width, height: jbig2.height, format: 'gbig2'};
 }
 
 const parseOtherImageFromZip = async function (zip, name, mime = 'image/png') {

package/vendor/dltech/ofd/ofd_render.js

@@ -470,8 +470,9 @@ export const renderTextObject = function (drawParamResObj, fontResObj, textObjec
     for (const textCodePoint of textCodePointList) {
         if (textCodePoint && !isNaN(textCodePoint.x)) {
             let text = document.createElementNS('http://www.w3.org/2000/svg', 'text');
-            text.setAttribute('x', textCodePoint.x);
-            text.setAttribute('y', textCodePoint.y);
+            text.setAttribute('x', textCodePoint.xPositions?.join(' ') || textCodePoint.x);
+            text.setAttribute('y', textCodePoint.yPositions?.join(' ') || textCodePoint.y);
+            text.setAttributeNS('http://www.w3.org/XML/1998/namespace', 'xml:space', 'preserve');
             text.textContent = textCodePoint.text;
             if (ctm) {
                 const ctms = parseCtm(ctm);
@@ -484,7 +485,7 @@ export const renderTextObject = function (drawParamResObj, fontResObj, textObjec
             const textFillColor = defaultFillColor || defaultStrokeColor || 'rgb(0, 0, 0)';
             text.setAttribute('fill', textFillColor);
             text.setAttribute('fill-opacity', defaultFillOpacity);
-            text.setAttribute('style', `font-weight: ${weight};font-size:${size}px;font-family: ${getFontFamily(fontResObj[font])};color:${textFillColor};`)
+            text.setAttribute('style', `white-space:pre;font-weight: ${weight};font-size:${size}px;font-family: ${getFontFamily(fontResObj[font])};color:${textFillColor};`)
             svg.appendChild(text);
         }
 

package/vendor/dltech/ofd/ofd_util.js

@@ -142,98 +142,54 @@ export const converterDpi = function (width) {
     return millimetersToPixel(width, Scale * 25.4);
 }
 
-export const deltaFormatter = function (delta) {
-    if (delta.indexOf("g") === -1) {
-        let floatList = [];
-        for (let f of delta.split(' ')) {
-            floatList.push(parseFloat(f));
-        }
-        return floatList;
-    } else {
-        const array = delta.split(' ');
-        let gFlag = false;
-        let gProcessing = false;
-        let gItemCount = 0;
-        let floatList = [];
-        for (const s of array) {
-            if ('g' === s) {
-                gFlag = true;
-            } else {
-                if (!s || s.trim().length == 0) {
-                    continue;
-                }
-                if (gFlag) {
-                    gItemCount = parseInt(s);
-                    gProcessing = true;
-                    gFlag = false;
-                } else if (gProcessing) {
-                    for (let j = 0; j < gItemCount; j++) {
-                        floatList.push(parseFloat(s));
-                    }
-                    gProcessing = false;
-                } else {
-                    floatList.push(parseFloat(s));
-                }
-            }
+export const deltaFormatter = function (delta, maxValues = 100000) {
+    const tokens = String(delta ?? '').trim().split(/\s+/);
+    const values = [];
+    const limit = Math.max(0, Math.min(100000, maxValues));
+    for (let i = 0; i < tokens.length && values.length < limit; i++) {
+        let count = 1;
+        if (tokens[i] === 'g') {
+            count = Number(tokens[++i]);
+            i++;
+            if (!Number.isSafeInteger(count) || count < 0) break;
         }
-        return floatList;
+        const value = Number(tokens[i]);
+        if (!tokens[i] || !Number.isFinite(value)) break;
+        count = Math.min(count, limit - values.length);
+        for (let j = 0; j < count; j++) values.push(value);
     }
+    return values;
 }
 
 export const calTextPoint = function (textCodes) {
-    let x = 0;
-    let y = 0;
-    let textCodePointList = [];
-    if (!textCodes) {
-        return textCodePointList;
-    }
-    for (let textCode of textCodes) {
-        if (!textCode) {
-            continue
-        }
-        x = parseFloat(textCode['@_X']);
-        y = parseFloat(textCode['@_Y']);
-
-        if (isNaN(x)) {
-            x = 0;
-        }
-        if (isNaN(y)) {
-            y = 0;
-        }
-
-        let deltaXList = [];
-        let deltaYList = [];
-        if (textCode['@_DeltaX'] && textCode['@_DeltaX'].length > 0) {
-            deltaXList = deltaFormatter(textCode['@_DeltaX']);
-        }
-        if (textCode['@_DeltaY'] && textCode['@_DeltaY'].length > 0) {
-            deltaYList = deltaFormatter(textCode['@_DeltaY']);
-        }
-        let textStr = textCode['#text'];
-        if (textStr) {
-            textStr += '';
-            textStr = decodeOfdText(textStr);
-            for (let i = 0; i < textStr.length; i++) {
-                if (i > 0 && deltaXList.length > 0) {
-                    x += deltaXList[(i - 1)];
-                }
-                if (i > 0 && deltaYList.length > 0) {
-                    y += deltaYList[(i - 1)];
-                }
-                let text = textStr.substring(i, i + 1);
-                let filterPointY = textCodePointList.filter((textCodePoint) => {
-                    return textCodePoint.y == converterDpi(y)
-                });
-                if (filterPointY && filterPointY.length) { // Y坐标相同，无需再创建text标签
-                    filterPointY[0].text += text;
-                } else {
-                    let textCodePoint = { 'x': converterDpi(x), 'y': converterDpi(y), 'text': text };
-                    textCodePointList.push(textCodePoint);
-                }
+    const runs = [];
+    for (const code of textCodes || []) {
+        if (code == null) continue;
+        const value = typeof code === 'string' ? code : code['#text'];
+        if (value == null || value === '') continue;
+        const text = decodeOfdText(String(value));
+        const count = Array.from(text).length;
+        const finite = value => Number.isFinite(Number.parseFloat(value)) ? Number.parseFloat(value) : 0;
+        const x = finite(code['@_X']);
+        const y = finite(code['@_Y']);
+        const positions = (start, delta) => {
+            const list = [converterDpi(start)];
+            for (const offset of deltaFormatter(delta, count - 1)) {
+                start += offset;
+                list.push(converterDpi(start));
             }
-        }
+            return list;
+        };
+        // One SVG text run per TextCode preserves shaping and avoids one DOM
+        // node per glyph. Position lists honor explicit advances (including
+        // spaces); omitted advances retain the browser's natural text advance.
+        runs.push({
+            x: converterDpi(x), y: converterDpi(y), text,
+            xPositions: positions(x, code['@_DeltaX']),
+            yPositions: positions(y, code['@_DeltaY']),
+        });
     }
-    return textCodePointList;
+    return runs;
 }
 
 export const replaceFirstSlash = function (str) {
@@ -311,6 +267,9 @@ let FONT_FAMILY = {
 };
 
 export const getFontFamily = function (font) {
+    if (typeof font !== 'string' || !font.trim()) {
+        return 'sans-serif';
+    }
     if (FONT_FAMILY[font.toLowerCase()]) {
         font = FONT_FAMILY[font.toLowerCase()];
     }

package/vendor/dltech/ofd/ses_signature_parser.js

@@ -33,6 +33,38 @@ const HexApi = unwrapDefault(Hex);
 const Base64Api = unwrapDefault(Base64);
 const ASN1Api = unwrapDefault(ASN1);
 
+// SignedData is not an SES seal. In particular, tax invoices use the GM/T
+// ContentInfo OID and draw their visible stamp as an ordinary page resource.
+const signedDataOids = new Set(['1.2.840.113549.1.7.2', '1.2.156.10197.6.1.4.2.2']);
+const universal = (node, number) => node?.tag?.tagClass === 0 && node.tag.tagNumber === number;
+const parseSignedData = function (node) {
+    if (!universal(node?.sub?.[0], 6)) return null;
+    const oidNode = node.sub[0];
+    const start = oidNode.stream.pos + oidNode.header;
+    const oid = oidNode.stream.parseOID(start, start + oidNode.length).split('\n', 1)[0];
+    if (!signedDataOids.has(oid)) throw new Error('Unsupported signature ContentInfo type');
+    const wrapper = node.sub[1];
+    const signed = wrapper?.sub?.[0];
+    if (!universal(node, 16) || node.sub.length !== 2 ||
+        wrapper?.tag?.tagClass !== 2 || wrapper.tag.tagNumber !== 0 ||
+        !wrapper.tag.tagConstructed || wrapper.sub.length !== 1 ||
+        !universal(signed, 16) || signed.sub.length < 4 ||
+        !universal(signed.sub[0], 2) || !universal(signed.sub[1], 17) ||
+        !universal(signed.sub[2], 16) || !universal(signed.sub[2]?.sub?.[0], 6) ||
+        !universal(signed.sub.at(-1), 17)) {
+        throw new Error('Malformed SignedData structure');
+    }
+    return {
+        type: 'signed-data',
+        verificationStatus: 'not-verified',
+        verifyRet: null,
+        SES_Signature: {
+            format: 'signed-data', contentType: oid, displayOnly: true,
+            verificationStatus: 'not-verified',
+        },
+    };
+};
+
 export const parseSesSignature = async function (zip, name, getEntry) {
     const entry = typeof getEntry === 'function' ? getEntry(zip, name) : zip.files[name];
     if (!entry) {
@@ -60,7 +92,10 @@ const decodeText = function (val) {
 const decode = function (der, offset) {
     offset = offset || 0;
     try {
-        const SES_Signature = decodeSES_Signature(der, offset);
+        const root = ASN1Api.decode(der, offset);
+        const signedData = parseSignedData(root);
+        if (signedData) return signedData;
+        const SES_Signature = decodeSES_Signature(root);
         const picture = SES_Signature?.toSign?.eseal?.esealInfo?.picture;
         if (!picture?.data?.byte?.length) {
             return {};
@@ -73,12 +108,15 @@ const decode = function (der, offset) {
             SES_Signature: {
                 realVersion: SES_Signature.realVersion,
                 displayOnly: true,
+                verificationStatus: 'not-verified',
                 pictureType: type,
                 pictureWidth: picture.width,
                 pictureHeight: picture.height,
                 sealName: SES_Signature.toSign?.eseal?.esealInfo?.property?.name,
             },
-            verifyRet: true,
+            // Displaying an image is not cryptographic signature verification.
+            verifyRet: null,
+            verificationStatus: 'not-verified',
         };
     } catch (e) {
         console.warn('[ofd] decode SES signature failed', e);
@@ -122,9 +160,7 @@ const parseTimeNode = function (node, utc) {
     return decodeUTCTime(raw);
 };
 
-const decodeSES_Signature = function (der, offset) {
-    offset = offset || 0;
-    const asn1 = ASN1Api.decode(der, offset);
+const decodeSES_Signature = function (asn1) {
     let SES_Signature;
     try {
         // V1