altium-toolkit 1.0.2 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "altium-toolkit",
-    "version": "1.0.2",
+    "version": "1.0.8",
     "description": "Altium document parsing and non-interactive rendering utilities",
     "keywords": [
         "altium",

package/src/core/altium/AltiumParser.mjs

@@ -27,6 +27,7 @@ import { SchematicImageParser } from './SchematicImageParser.mjs'
 import { SchematicNetlistBuilder } from './SchematicNetlistBuilder.mjs'
 import { SchematicComponentTextResolver } from './SchematicComponentTextResolver.mjs'
 import { SchematicStreamExtractor } from './SchematicStreamExtractor.mjs'
+import { SchematicWireNormalizer } from './SchematicWireNormalizer.mjs'
 import { CircuitJsonModelAdapter } from '../circuit-json/CircuitJsonModelAdapter.mjs'
 const {
     countMatchingKeys,
@@ -281,7 +282,7 @@ export class AltiumParser {
             )
         }
 
-        const lines = [
+        let lines = [
             ...lineRecords.map((record, index) => ({
                 x1: parseNumericField(record.fields, 'Location.X') || 0,
                 y1: parseNumericField(record.fields, 'Location.Y') || 0,
@@ -325,8 +326,22 @@ export class AltiumParser {
                 )
             )
         ]
-        const polygons =
+        const pins = parseSchematicPins(pinRecords)
+        const junctions = SchematicJunctionParser.parseSchematicJunctions(
+            recordIndexAwareRecords
+        )
+        lines = SchematicWireNormalizer.extendCollapsedPolylineEndpoints(
+            lines,
+            pins,
+            junctions
+        )
+        let polygons =
             SchematicPrimitiveParser.parseSchematicPolygons(polygonRecords)
+        ;({ lines, polygons } =
+            SchematicWireNormalizer.normalizeStandaloneCalloutArrowheads(
+                lines,
+                polygons
+            ))
         const arcs = SchematicPrimitiveParser.parseSchematicArcs(arcRecords)
         const ellipses =
             SchematicPrimitiveParser.parseSchematicEllipses(ellipseRecords)
@@ -348,9 +363,6 @@ export class AltiumParser {
         const { sheetSymbols, sheetEntries } = SchematicSheetParser.parse(
             recordIndexAwareRecords
         )
-        const junctions = SchematicJunctionParser.parseSchematicJunctions(
-            recordIndexAwareRecords
-        )
         const busEntries = SchematicBusEntryParser.parseSchematicBusEntries(
             recordIndexAwareRecords
         )
@@ -360,7 +372,6 @@ export class AltiumParser {
                 arrayBuffer
             )
 
-        const pins = parseSchematicPins(pinRecords)
         const ports = parseSchematicPorts(portRecords, lines)
         const crosses = parseSchematicCrosses(crossRecords)
         let texts = drawableTextRecords

package/src/core/altium/AsciiRecordParser.mjs

@@ -26,7 +26,16 @@ export class AsciiRecordParser {
 
             for (const chunk of chunks) {
                 const candidate = chunk.trim()
-                if (!AsciiRecordParser.#isRecordCandidate(candidate)) continue
+                if (!AsciiRecordParser.#isRecordCandidate(candidate)) {
+                    if (
+                        AsciiRecordParser.#isRecordFieldPrefixFragment(
+                            candidate
+                        )
+                    ) {
+                        pendingPrefix += candidate
+                    }
+                    continue
+                }
 
                 const headerPrefix =
                     AsciiRecordParser.#extractHeaderFieldPrefix(candidate)
@@ -65,6 +74,24 @@ export class AsciiRecordParser {
         return candidate.split('|').length >= 4
     }
 
+    /**
+     * Returns true when a short printable fragment contains fields that belong
+     * to the next record marker in the same run.
+     * @param {string} candidate
+     * @returns {boolean}
+     */
+    static #isRecordFieldPrefixFragment(candidate) {
+        if (!candidate.startsWith('|')) return false
+        if (!candidate.includes('=')) return false
+        if (AsciiRecordParser.#hasRecordMarker(candidate)) return false
+
+        const segments = candidate.split('|').filter(Boolean)
+        return segments.every((segment) => {
+            const separatorIndex = segment.indexOf('=')
+            return separatorIndex > 0
+        })
+    }
+
     /**
      * Returns true when a printable fragment contains its marker field.
      * @param {string} candidate

package/src/core/altium/SchematicPinDesignatorInferer.mjs

@@ -9,8 +9,8 @@ export class SchematicPinDesignatorInferer {
     /**
      * Infers omitted source-order pin numbers for compact four-pin symbols
      * whose printable records keep enough numeric hints to prove the sequence.
-     * @param {{ x: number, y: number, length: number, designator: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
-     * @returns {{ x: number, y: number, length: number, designator: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[] | null}
+     * @param {{ x: number, y: number, length: number, name?: string, designator: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[]} pins
+     * @returns {{ x: number, y: number, length: number, name?: string, designator: string, orientation: 'left' | 'right' | 'top' | 'bottom' }[] | null}
      */
     static inferSequentialCompactFourPinDesignators(pins) {
         if (
@@ -40,7 +40,16 @@ export class SchematicPinDesignatorInferer {
             }
         }
 
-        if (explicitCount < 2 || explicitCount === pins.length) {
+        if (explicitCount < 2) {
+            return null
+        }
+
+        if (
+            explicitCount === pins.length &&
+            !SchematicPinDesignatorInferer.#hasRepeatedCompactTerminalNames(
+                pins
+            )
+        ) {
             return null
         }
 
@@ -50,6 +59,30 @@ export class SchematicPinDesignatorInferer {
         }))
     }
 
+    /**
+     * Returns true when a compact four-pin owner repeats internal terminal
+     * names, so visible pin numbers are the useful external labels.
+     * @param {{ name?: string }[]} pins
+     * @returns {boolean}
+     */
+    static #hasRepeatedCompactTerminalNames(pins) {
+        const names = pins.map((pin) => String(pin.name || '').trim())
+
+        if (names.some((name) => !name)) {
+            return false
+        }
+
+        const counts = new Map()
+        for (const name of names) {
+            counts.set(name, (counts.get(name) || 0) + 1)
+        }
+
+        return (
+            counts.size < pins.length &&
+            [...counts.values()].every((count) => count > 1)
+        )
+    }
+
     /**
      * Infers omitted numeric labels for compact two-column owners whose
      * physical side geometry implies the same sequence Altium displays.

package/src/core/altium/SchematicPinParser.mjs

@@ -71,6 +71,11 @@ export class SchematicPinParser {
                         record.fields,
                         'SymBol_Outer'
                     ) || undefined,
+                color: ParserUtils.toColor(record.fields.Color, '#000000'),
+                labelColor: ParserUtils.toColor(
+                    record.fields.TextColor,
+                    '#1f1f1f'
+                ),
                 ownerIndex
             })
         }
@@ -397,7 +402,7 @@ export class SchematicPinParser {
      * Expands a schematic polyline record into drawable line segments.
      * @param {Record<string, string | string[]>} fields
      * @param {{ isBus?: boolean, recordType?: string }} [options]
-     * @returns {{ x1: number, y1: number, x2: number, y2: number, color: string, width: number, lineStyle: number, isBus?: boolean, recordType?: string }[]}
+     * @returns {{ x1: number, y1: number, x2: number, y2: number, color: string, width: number, lineStyle: number, isBus?: boolean, recordType?: string, omittedEndpointAxis?: 'x' | 'y', sourceLocationCount?: number }[]}
      */
     static parseSchematicPolyline(fields, options = {}) {
         const points = SchematicPinParser.#collectSchematicPointList(fields)
@@ -408,17 +413,27 @@ export class SchematicPinParser {
         for (let index = 1; index < points.length; index += 1) {
             const previous = points[index - 1]
             const current = points[index]
+            const omittedEndpointAxis =
+                SchematicPinParser.#resolveOmittedPointAxis(current)
 
             segments.push({
                 x1: previous.x,
                 y1: previous.y,
                 x2: current.x,
                 y2: current.y,
-                color: ParserUtils.toColor(fields.Color, '#a44a1b'),
+                color: ParserUtils.toColor(
+                    fields.Color,
+                    SchematicPinParser.#resolveDefaultPolylineColor(
+                        fields,
+                        options.recordType
+                    )
+                ),
                 width: ParserUtils.parseNumericField(fields, 'LineWidth') || 1,
                 lineStyle,
                 isBus: options.isBus === true ? true : undefined,
-                recordType: options.recordType || undefined
+                recordType: options.recordType || undefined,
+                omittedEndpointAxis: omittedEndpointAxis || undefined,
+                sourceLocationCount: points.length
             })
         }
 
@@ -449,7 +464,10 @@ export class SchematicPinParser {
                 y1: previous.y,
                 x2: current.x,
                 y2: current.y,
-                color: ParserUtils.toColor(fields.Color, '#a44a1b'),
+                color: ParserUtils.toColor(
+                    fields.Color,
+                    SchematicPinParser.#resolveDefaultPolylineColor(fields, '7')
+                ),
                 width: ParserUtils.parseNumericField(fields, 'LineWidth') || 1,
                 lineStyle
             })
@@ -463,7 +481,10 @@ export class SchematicPinParser {
             y1: lastPoint.y,
             x2: firstPoint.x,
             y2: firstPoint.y,
-            color: ParserUtils.toColor(fields.Color, '#a44a1b'),
+            color: ParserUtils.toColor(
+                fields.Color,
+                SchematicPinParser.#resolveDefaultPolylineColor(fields, '7')
+            ),
             width: ParserUtils.parseNumericField(fields, 'LineWidth') || 1,
             lineStyle
         })
@@ -489,6 +510,21 @@ export class SchematicPinParser {
         return ParserUtils.parseNumericField(fields, 'LineStyle') || 0
     }
 
+    /**
+     * Resolves the fallback stroke color for schematic drawing primitives.
+     * @param {Record<string, string | string[]>} fields
+     * @param {string | undefined} recordType
+     * @returns {string}
+     */
+    static #resolveDefaultPolylineColor(fields, recordType) {
+        const resolvedRecordType =
+            recordType || ParserUtils.getField(fields, 'RECORD')
+
+        return resolvedRecordType === '6' || resolvedRecordType === '7'
+            ? '#000000'
+            : '#a44a1b'
+    }
+
     /**
      * Collects a schematic point list, carrying forward a missing coordinate
      * axis from the preceding point when Altium omitted an unchanged value.
@@ -500,6 +536,7 @@ export class SchematicPinParser {
             fields,
             'LocationCount'
         )
+        const closesPolygon = ParserUtils.getField(fields, 'RECORD') === '7'
 
         if (locationCount === null || locationCount < 2) {
             return []
@@ -524,17 +561,92 @@ export class SchematicPinParser {
                 break
             }
 
-            points.push({ x: pointX, y: pointY })
-            previousX = pointX
-            previousY = pointY
+            const point =
+                closesPolygon && index === locationCount
+                    ? SchematicPinParser.#resolveCollapsedFinalPolygonPoint(
+                          x,
+                          y,
+                          pointX,
+                          pointY,
+                          points
+                      )
+                    : { x: pointX, y: pointY }
+
+            points.push({ ...point, sourceX: x, sourceY: y })
+            previousX = point.x
+            previousY = point.y
         }
 
         return points
     }
 
+    /**
+     * Resolves which coordinate axis was omitted on one source point.
+     * @param {{ sourceX?: number | null, sourceY?: number | null }} point
+     * @returns {'x' | 'y' | null}
+     */
+    static #resolveOmittedPointAxis(point) {
+        if (point.sourceX === null && point.sourceY !== null) {
+            return 'x'
+        }
+
+        if (point.sourceX !== null && point.sourceY === null) {
+            return 'y'
+        }
+
+        return null
+    }
+
+    /**
+     * Recovers a closed polygon's final omitted axis when carrying the previous
+     * point would collapse the last side into a duplicate point.
+     * @param {number | null} sourceX
+     * @param {number | null} sourceY
+     * @param {number} pointX
+     * @param {number} pointY
+     * @param {{ x: number, y: number }[]} points
+     * @returns {{ x: number, y: number }}
+     */
+    static #resolveCollapsedFinalPolygonPoint(
+        sourceX,
+        sourceY,
+        pointX,
+        pointY,
+        points
+    ) {
+        const previousPoint = points.at(-1)
+        const firstPoint = points[0]
+
+        if (!previousPoint || !firstPoint) {
+            return { x: pointX, y: pointY }
+        }
+
+        if (
+            sourceY === null &&
+            sourceX !== null &&
+            firstPoint.y !== previousPoint.y
+        ) {
+            if (pointX === previousPoint.x && pointY === previousPoint.y) {
+                return { x: pointX, y: firstPoint.y }
+            }
+        }
+
+        if (
+            sourceX === null &&
+            sourceY !== null &&
+            firstPoint.x !== previousPoint.x
+        ) {
+            if (pointX === previousPoint.x && pointY === previousPoint.y) {
+                return { x: firstPoint.x, y: pointY }
+            }
+        }
+
+        return { x: pointX, y: pointY }
+    }
+
     /**
      * Deduces the visible pins for one schematic symbol owner.
-     * @param {{ x: number, y: number, length: number, conglomerate?: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, ownerIndex: string }[]} pins
+     * @param {{ x: number, y: number, length: number, conglomerate?: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color?: string, labelColor?: string, ownerIndex: string }[]} pins
      * @returns {{ x: number, y: number, length: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color: string, labelColor: string, labelMode: 'hidden' | 'number-only' | 'name-only' | 'name-and-number', ownerIndex: string }[]}
      */
     static #normalizeSchematicPinGroup(pins) {
@@ -626,8 +738,8 @@ export class SchematicPinParser {
 
         return normalizedPins.map(({ conglomerate, ...pin }) => ({
             ...pin,
-            color: '#0000ff',
-            labelColor: '#1f1f1f',
+            color: pin.color || '#000000',
+            labelColor: pin.labelColor || '#1f1f1f',
             labelMode
         }))
     }
@@ -649,7 +761,7 @@ export class SchematicPinParser {
             pins.length < 3 ||
             pins.length > 4 ||
             orientationCount < 3 ||
-            pins.some((pin) => String(pin.designator || '').trim())
+            !SchematicPinParser.#hasOptionalNumericPinDesignators(pins)
         ) {
             return false
         }
@@ -663,6 +775,19 @@ export class SchematicPinParser {
         )
     }
 
+    /**
+     * Returns true when compact owner-drawn terminal glyph pins have either no
+     * external designators or ordinary numeric pin numbers.
+     * @param {{ designator: string }[]} pins
+     * @returns {boolean}
+     */
+    static #hasOptionalNumericPinDesignators(pins) {
+        return pins.every((pin) => {
+            const designator = String(pin.designator || '').trim()
+            return !designator || /^\d+$/.test(designator)
+        })
+    }
+
     /**
      * Returns true for one-letter terminal glyphs commonly drawn inside
      * transistor-style schematic symbols.
@@ -726,8 +851,8 @@ export class SchematicPinParser {
 
     /**
      * Removes duplicate pin records emitted for alternate display modes.
-     * @param {{ x: number, y: number, length: number, conglomerate?: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, ownerIndex: string }[]} pins
-     * @returns {{ x: number, y: number, length: number, conglomerate?: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, ownerIndex: string }[]}
+     * @param {{ x: number, y: number, length: number, conglomerate?: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color?: string, labelColor?: string, ownerIndex: string }[]} pins
+     * @returns {{ x: number, y: number, length: number, conglomerate?: number, name: string, nameSegments?: { text: string, overline: boolean }[], designator: string, orientation: 'left' | 'right' | 'top' | 'bottom', electrical?: number, symbolOuter?: number, color?: string, labelColor?: string, ownerIndex: string }[]}
      */
     static #dedupeSchematicPins(pins) {
         const seen = new Set()

package/src/core/altium/SchematicPrimitiveParser.mjs

@@ -96,10 +96,12 @@ export class SchematicPrimitiveParser {
                     return null
                 }
 
+                const color = toColor(record.fields.Color, '#000000')
+
                 return {
                     points,
-                    color: toColor(record.fields.Color, '#a44a1b'),
-                    fill: toColor(record.fields.AreaColor, '#ffe16f'),
+                    color,
+                    fill: toColor(record.fields.AreaColor, color),
                     isSolid: parseBoolean(record.fields.IsSolid),
                     transparent: parseBoolean(record.fields.Transparent),
                     lineWidth:
@@ -699,18 +701,87 @@ export class SchematicPrimitiveParser {
         }
 
         const points = []
+        let previousX = null
+        let previousY = null
 
         for (let index = 1; index <= locationCount; index += 1) {
             const x = parseNumericField(fields, 'X' + index)
             const y = parseNumericField(fields, 'Y' + index)
 
-            if (x === null || y === null) {
+            if (x === null && y === null) {
+                break
+            }
+
+            const pointX = x === null ? previousX : x
+            const pointY = y === null ? previousY : y
+
+            if (pointX === null || pointY === null) {
                 break
             }
 
-            points.push({ x, y })
+            const point =
+                index === locationCount
+                    ? SchematicPrimitiveParser.#resolveCollapsedFinalPolygonPoint(
+                          x,
+                          y,
+                          pointX,
+                          pointY,
+                          points
+                      )
+                    : { x: pointX, y: pointY }
+
+            points.push(point)
+            previousX = point.x
+            previousY = point.y
         }
 
         return points
     }
+
+    /**
+     * Recovers a closed polygon's final omitted axis when carrying the previous
+     * point would collapse the last side into a duplicate point.
+     * @param {number | null} sourceX
+     * @param {number | null} sourceY
+     * @param {number} pointX
+     * @param {number} pointY
+     * @param {{ x: number, y: number }[]} points
+     * @returns {{ x: number, y: number }}
+     */
+    static #resolveCollapsedFinalPolygonPoint(
+        sourceX,
+        sourceY,
+        pointX,
+        pointY,
+        points
+    ) {
+        const previousPoint = points.at(-1)
+        const firstPoint = points[0]
+
+        if (!previousPoint || !firstPoint) {
+            return { x: pointX, y: pointY }
+        }
+
+        if (
+            sourceY === null &&
+            sourceX !== null &&
+            firstPoint.y !== previousPoint.y
+        ) {
+            if (pointX === previousPoint.x && pointY === previousPoint.y) {
+                return { x: pointX, y: firstPoint.y }
+            }
+        }
+
+        if (
+            sourceX === null &&
+            sourceY !== null &&
+            firstPoint.x !== previousPoint.x
+        ) {
+            if (pointX === previousPoint.x && pointY === previousPoint.y) {
+                return { x: firstPoint.x, y: pointY }
+            }
+        }
+
+        return { x: pointX, y: pointY }
+    }
 }

package/src/core/altium/SchematicTextParser.mjs

@@ -33,7 +33,7 @@ export class SchematicTextParser {
     /**
      * Builds a font table from the sheet header.
      * @param {Record<string, string | string[]> | undefined} fields
-     * @returns {Record<string, { size: number, family: string, bold: boolean, rotation: number }>}
+     * @returns {Record<string, { size: number, family: string, bold: boolean, italic: boolean, rotation: number }>}
      */
     static extractSchematicFonts(fields) {
         const count = ParserUtils.parseNumericField(fields, 'FontIdCount') || 0
@@ -47,6 +47,7 @@ export class SchematicTextParser {
                     ParserUtils.getField(fields, 'FontName' + index)
                 ),
                 bold: ParserUtils.parseBoolean(fields?.['Bold' + index]),
+                italic: ParserUtils.parseBoolean(fields?.['Italic' + index]),
                 rotation:
                     ParserUtils.parseNumericField(fields, 'Rotation' + index) ||
                     0
@@ -61,8 +62,8 @@ export class SchematicTextParser {
      * @param {Record<string, string | string[]>} fields
      * @param {Record<string, string>} metadata
      * @param {{ width: number, marginWidth: number, titleBlockOn?: boolean }} sheet
-     * @param {Record<string, { size: number, family: string, bold: boolean, rotation: number }>} fonts
-     * @returns {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] } | null}
+     * @param {Record<string, { size: number, family: string, bold: boolean, italic?: boolean, rotation: number }>} fonts
+     * @returns {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end', powerPortDirection?: 'up' | 'down' | 'left' | 'right', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] } | null}
      */
     static normalizeSchematicTextRecord(fields, metadata, sheet, fonts) {
         const x = ParserUtils.parseNumericField(fields, 'Location.X')
@@ -121,6 +122,7 @@ export class SchematicTextParser {
             fontSize: SchematicTextParser.#toSvgFontSize(font.size),
             fontFamily: font.family,
             fontWeight: font.bold ? 700 : 400,
+            ...(font.italic ? { fontStyle: 'italic' } : {}),
             rotation,
             sourceOrientation:
                 sourceOrientation === null ? undefined : sourceOrientation,
@@ -155,8 +157,8 @@ export class SchematicTextParser {
      * @param {{ fields: Record<string, string | string[]> }[]} records
      * @param {Record<string, string>} metadata
      * @param {number} sheetWidth
-     * @param {Record<string, { size: number, family: string, bold: boolean, rotation: number }>} fonts
-     * @returns {{ title: string, revision: string, documentNumber: string, sheetNumber: string, sheetTotal: string, date: string, drawnBy: string, footerHints: Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }>> }}
+     * @param {Record<string, { size: number, family: string, bold: boolean, italic?: boolean, rotation: number }>} fonts
+     * @returns {{ title: string, revision: string, documentNumber: string, sheetNumber: string, sheetTotal: string, date: string, drawnBy: string, footerHints: Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>> }}
      */
     static extractSchematicTitleBlock(records, metadata, sheetWidth, fonts) {
         const footerTexts = records
@@ -248,8 +250,8 @@ export class SchematicTextParser {
     /**
      * Normalizes one visible footer text record into a title-block layout hint.
      * @param {Record<string, string | string[]>} fields
-     * @param {Record<string, { size: number, family: string, bold: boolean, rotation: number }>} fonts
-     * @returns {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number } | null}
+     * @param {Record<string, { size: number, family: string, bold: boolean, italic?: boolean, rotation: number }>} fonts
+     * @returns {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string } | null}
      */
     static #normalizeTitleBlockFooterRecord(fields, fonts) {
         const text = ParserUtils.getDisplayText(fields)
@@ -274,14 +276,15 @@ export class SchematicTextParser {
             ),
             fontSize: font.size,
             fontFamily: font.family,
-            fontWeight: font.bold ? 700 : 400
+            fontWeight: font.bold ? 700 : 400,
+            ...(font.italic ? { fontStyle: 'italic' } : {})
         }
     }
 
     /**
      * Maps visible footer rows onto title-block fields.
-     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }[]} footerTexts
-     * @returns {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }>>}
+     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]} footerTexts
+     * @returns {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>>}
      */
     static #collectSchematicTitleBlockFooterHints(footerTexts) {
         const rows = SchematicTextParser.#groupTitleBlockFooterRows(footerTexts)
@@ -325,8 +328,8 @@ export class SchematicTextParser {
 
     /**
      * Groups footer texts by their shared baseline row.
-     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }[]} footerTexts
-     * @returns {Array<{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }[]>}
+     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]} footerTexts
+     * @returns {Array<{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]>}
      */
     static #groupTitleBlockFooterRows(footerTexts) {
         const tolerance = 8
@@ -372,7 +375,7 @@ export class SchematicTextParser {
     /**
      * Extracts a visible footer `Drawn By` value from the bottom-most footer
      * row when hidden metadata does not provide one.
-     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }[]} footerTexts
+     * @param {{ text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }[]} footerTexts
      * @param {Record<string, string>} metadata
      * @returns {string}
      */
@@ -397,8 +400,8 @@ export class SchematicTextParser {
 
     /**
      * Removes the non-rendered text payload from stored footer hints.
-     * @param {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }>>} footerHints
-     * @returns {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number }>>}
+     * @param {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { text: string, x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>>} footerHints
+     * @returns {Partial<Record<'title' | 'documentNumber' | 'revision' | 'sheetNumber' | 'sheetTotal', { x: number, y: number, color: string, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string }>>}
      */
     static #stripSchematicTitleBlockHintText(footerHints) {
         return Object.fromEntries(
@@ -622,13 +625,14 @@ export class SchematicTextParser {
 
     /**
      * Returns the default schematic font when no sheet font entry exists.
-     * @returns {{ size: number, family: string, bold: boolean, rotation: number }}
+     * @returns {{ size: number, family: string, bold: boolean, italic: boolean, rotation: number }}
      */
     static #defaultSchematicFont() {
         return {
             size: 10,
             family: 'Times New Roman',
             bold: false,
+            italic: false,
             rotation: 0
         }
     }
@@ -670,9 +674,9 @@ export class SchematicTextParser {
 
     /**
      * Adds note box metadata to one decoded schematic note record.
-     * @param {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end' }} textRecord
+     * @param {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end' }} textRecord
      * @param {Record<string, string | string[]>} fields
-     * @returns {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }}
+     * @returns {{ x: number, y: number, text: string, color: string, hidden: boolean, name: string, ownerIndex?: string, recordType: string, style: number, fontSize: number, fontFamily: string, fontWeight: number, fontStyle?: string, rotation: number, sourceOrientation?: number, isMirrored?: boolean, anchor: 'start' | 'middle' | 'end', cornerX?: number, cornerY?: number, fill?: string, borderColor?: string, isSolid?: boolean, showBorder?: boolean, textMargin?: number, noteLines?: string[] }}
      */
     static #normalizeSchematicNoteRecord(textRecord, fields) {
         const noteLines = SchematicTextParser.#decodeSchematicNoteLines(