altium-toolkit 1.1.22 → 1.1.24

package/src/core/altium/UnsupportedFeatureReportBuilder.mjs

@@ -0,0 +1,380 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Builds summaries of preserved parser data that is not modeled yet.
+ */
+export class UnsupportedFeatureReportBuilder {
+    static SCHEMA = 'altium-toolkit.unsupported-features.a1'
+
+    /**
+     * Builds an unsupported feature report.
+     * @param {{ models?: object[], recordTypes?: object[], rawRecords?: object[], opaqueRecords?: object[], diagnostics?: object[] }} [input] Report input.
+     * @returns {object}
+     */
+    static build(input = {}) {
+        const models = UnsupportedFeatureReportBuilder.#models(input)
+        const recordTypes =
+            UnsupportedFeatureReportBuilder.#unsupportedRecordTypes(
+                input,
+                models
+            )
+        const rawRecords = UnsupportedFeatureReportBuilder.#rawRecords(
+            input,
+            models
+        )
+        const opaqueRecords = UnsupportedFeatureReportBuilder.#opaqueRecords(
+            input,
+            models
+        )
+        const diagnostics = UnsupportedFeatureReportBuilder.#diagnostics(
+            input,
+            models
+        )
+        const itemCount =
+            recordTypes.length +
+            rawRecords.length +
+            opaqueRecords.length +
+            diagnostics.length
+
+        return {
+            schema: UnsupportedFeatureReportBuilder.SCHEMA,
+            summary: {
+                modelCount: models.length,
+                unsupportedRecordTypeCount: recordTypes.length,
+                rawRecordCount: rawRecords.length,
+                opaqueRecordCount: opaqueRecords.length,
+                diagnosticCount: diagnostics.length,
+                itemCount,
+                status: itemCount ? 'unsupported' : 'supported'
+            },
+            recordTypes,
+            rawRecords,
+            opaqueRecords,
+            diagnostics
+        }
+    }
+
+    /**
+     * Normalizes model input.
+     * @param {object} input Report input.
+     * @returns {object[]}
+     */
+    static #models(input) {
+        return Array.isArray(input?.models) ? input.models : []
+    }
+
+    /**
+     * Collects unsupported record type summaries.
+     * @param {object} input Report input.
+     * @param {object[]} models Parser roots.
+     * @returns {object[]}
+     */
+    static #unsupportedRecordTypes(input, models) {
+        return [
+            ...(Array.isArray(input?.recordTypes)
+                ? input.recordTypes.map((recordType) => ({
+                      row: recordType || {},
+                      fileName: recordType?.fileName || '',
+                      domain: recordType?.domain || ''
+                  }))
+                : []),
+            ...models.flatMap((model) =>
+                UnsupportedFeatureReportBuilder.#modelRecordTypes(model)
+            )
+        ]
+            .filter(({ row }) => row?.supported === false)
+            .map(({ row, fileName, domain }) =>
+                UnsupportedFeatureReportBuilder.#stripUndefined({
+                    fileName,
+                    domain,
+                    recordType:
+                        UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                            row.recordType
+                        ),
+                    name: row.name,
+                    family: row.family,
+                    count: UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                        row.count
+                    )
+                })
+            )
+    }
+
+    /**
+     * Collects record type rows from one parser root.
+     * @param {object} model Parser root.
+     * @returns {{ row: object, fileName: string, domain: string }[]}
+     */
+    static #modelRecordTypes(model) {
+        const fileName = String(model?.fileName || '')
+        return [
+            ...UnsupportedFeatureReportBuilder.#domainRows(
+                model?.schematic?.recordTypes,
+                fileName,
+                'schematic'
+            ),
+            ...UnsupportedFeatureReportBuilder.#domainRows(
+                model?.schematicLibrary?.recordTypes,
+                fileName,
+                'schematic-library'
+            )
+        ]
+    }
+
+    /**
+     * Wraps domain rows with file and domain metadata.
+     * @param {object[] | undefined} rows Rows.
+     * @param {string} fileName Source file name.
+     * @param {string} domain Parser domain.
+     * @returns {{ row: object, fileName: string, domain: string }[]}
+     */
+    static #domainRows(rows, fileName, domain) {
+        return (Array.isArray(rows) ? rows : []).map((row) => ({
+            row,
+            fileName,
+            domain
+        }))
+    }
+
+    /**
+     * Collects unsupported or unparsed raw record rows.
+     * @param {object} input Report input.
+     * @param {object[]} models Parser roots.
+     * @returns {object[]}
+     */
+    static #rawRecords(input, models) {
+        return [
+            ...(Array.isArray(input?.rawRecords)
+                ? input.rawRecords.map((record) => ({
+                      record: record || {},
+                      fileName: record?.fileName || '',
+                      domain: record?.domain || 'pcb'
+                  }))
+                : []),
+            ...models.flatMap((model) =>
+                UnsupportedFeatureReportBuilder.#modelRawRecords(model)
+            )
+        ]
+            .filter(
+                ({ record }) =>
+                    record?.supported === false || record?.parsed === false
+            )
+            .map(({ record, fileName, domain }) =>
+                UnsupportedFeatureReportBuilder.#stripUndefined({
+                    fileName,
+                    domain,
+                    sourceStream: record.sourceStream,
+                    sourceStorage: record.sourceStorage,
+                    recordIndex:
+                        UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                            record.recordIndex
+                        ),
+                    family: record.family,
+                    type: record.type,
+                    typeId: UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                        record.typeId
+                    ),
+                    byteLength:
+                        UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                            record.byteLength
+                        ),
+                    supported: record.supported,
+                    parsed: record.parsed
+                })
+            )
+    }
+
+    /**
+     * Collects raw records from one parser root.
+     * @param {object} model Parser root.
+     * @returns {{ record: object, fileName: string, domain: string }[]}
+     */
+    static #modelRawRecords(model) {
+        const fileName = String(model?.fileName || '')
+        return [
+            ...UnsupportedFeatureReportBuilder.#rawDomainRows(
+                model?.pcb?.rawRecords,
+                fileName,
+                'pcb'
+            ),
+            ...UnsupportedFeatureReportBuilder.#rawDomainRows(
+                (model?.pcbLibrary?.footprints || []).flatMap(
+                    (footprint) => footprint.rawRecords || []
+                ),
+                fileName,
+                'pcb-library'
+            ),
+            ...UnsupportedFeatureReportBuilder.#rawDomainRows(
+                model?.schematic?.rawRecords,
+                fileName,
+                'schematic'
+            ),
+            ...UnsupportedFeatureReportBuilder.#rawDomainRows(
+                (model?.schematicLibrary?.components || []).flatMap(
+                    (component) => component.rawRecords || []
+                ),
+                fileName,
+                'schematic-library'
+            )
+        ]
+    }
+
+    /**
+     * Wraps raw record rows with source metadata.
+     * @param {object[] | undefined} records Raw records.
+     * @param {string} fileName Source file name.
+     * @param {string} domain Parser domain.
+     * @returns {{ record: object, fileName: string, domain: string }[]}
+     */
+    static #rawDomainRows(records, fileName, domain) {
+        return (Array.isArray(records) ? records : []).map((record) => ({
+            record,
+            fileName,
+            domain
+        }))
+    }
+
+    /**
+     * Collects opaque preserved rows.
+     * @param {object} input Report input.
+     * @param {object[]} models Parser roots.
+     * @returns {object[]}
+     */
+    static #opaqueRecords(input, models) {
+        return [
+            ...(Array.isArray(input?.opaqueRecords)
+                ? input.opaqueRecords.map((record) => ({
+                      record: record || {},
+                      fileName: record?.fileName || '',
+                      domain: record?.domain || 'schematic'
+                  }))
+                : []),
+            ...models.flatMap((model) =>
+                UnsupportedFeatureReportBuilder.#modelOpaqueRecords(model)
+            )
+        ].map(({ record, fileName, domain }) =>
+            UnsupportedFeatureReportBuilder.#stripUndefined({
+                fileName,
+                domain,
+                sourceStream: record.sourceStream,
+                sourceStorage: record.sourceStorage,
+                frameType: UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                    record.frameType
+                ),
+                recordIndex: UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                    record.recordIndex
+                ),
+                byteLength: UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                    record.byteLength
+                )
+            })
+        )
+    }
+
+    /**
+     * Collects opaque rows from one parser root.
+     * @param {object} model Parser root.
+     * @returns {{ record: object, fileName: string, domain: string }[]}
+     */
+    static #modelOpaqueRecords(model) {
+        const fileName = String(model?.fileName || '')
+        return [
+            ...UnsupportedFeatureReportBuilder.#rawDomainRows(
+                model?.schematic?.opaqueRecords,
+                fileName,
+                'schematic'
+            ),
+            ...UnsupportedFeatureReportBuilder.#rawDomainRows(
+                (model?.schematicLibrary?.components || []).flatMap(
+                    (component) => component.opaqueRecords || []
+                ),
+                fileName,
+                'schematic-library'
+            )
+        ].map(({ record, ...metadata }) => ({ record, ...metadata }))
+    }
+
+    /**
+     * Collects unsupported diagnostics.
+     * @param {object} input Report input.
+     * @param {object[]} models Parser roots.
+     * @returns {object[]}
+     */
+    static #diagnostics(input, models) {
+        return [
+            ...(Array.isArray(input?.diagnostics)
+                ? input.diagnostics.map((diagnostic) => ({
+                      diagnostic: diagnostic || {},
+                      fileName: diagnostic?.fileName || ''
+                  }))
+                : []),
+            ...models.flatMap((model) =>
+                (model?.diagnostics || []).map((diagnostic) => ({
+                    diagnostic,
+                    fileName: model.fileName || diagnostic.fileName || ''
+                }))
+            )
+        ]
+            .filter(({ diagnostic }) =>
+                UnsupportedFeatureReportBuilder.#isUnsupportedDiagnostic(
+                    diagnostic
+                )
+            )
+            .map(({ diagnostic, fileName }) =>
+                UnsupportedFeatureReportBuilder.#stripUndefined({
+                    fileName,
+                    code: diagnostic.code,
+                    severity: diagnostic.severity,
+                    message: diagnostic.message,
+                    source: diagnostic.source,
+                    sourceStream: diagnostic.sourceStream,
+                    sourceStorage: diagnostic.sourceStorage,
+                    recordIndex:
+                        UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                            diagnostic.recordIndex
+                        ),
+                    recordType:
+                        UnsupportedFeatureReportBuilder.#finiteOrUndefined(
+                            diagnostic.recordType
+                        ),
+                    errorKind: diagnostic.errorKind
+                })
+            )
+    }
+
+    /**
+     * Returns true for unsupported-feature diagnostics.
+     * @param {object} diagnostic Diagnostic row.
+     * @returns {boolean}
+     */
+    static #isUnsupportedDiagnostic(diagnostic) {
+        if (!diagnostic || typeof diagnostic !== 'object') return false
+        if (diagnostic.errorKind === 'unsupported-feature') return true
+        return String(diagnostic.code || '')
+            .toLowerCase()
+            .includes('unsupported')
+    }
+
+    /**
+     * Returns a finite number or undefined.
+     * @param {unknown} value Candidate value.
+     * @returns {number | undefined}
+     */
+    static #finiteOrUndefined(value) {
+        const number = Number(value)
+        return Number.isFinite(number) ? number : undefined
+    }
+
+    /**
+     * Removes undefined values from one row.
+     * @param {object} row Row to clean.
+     * @returns {object}
+     */
+    static #stripUndefined(row) {
+        return Object.fromEntries(
+            Object.entries(row).filter(([, value]) => value !== undefined)
+        )
+    }
+}

package/src/parser.mjs

@@ -2,7 +2,7 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-export { BinaryReader } from './core/BinaryReader.mjs'
+export { BinaryReader, BinaryReaderCursor } from './core/BinaryReader.mjs'
 export { OleCompoundDocument } from './core/ole/OleCompoundDocument.mjs'
 export { OleConstants } from './core/ole/OleConstants.mjs'
 export { OleDirectoryEntry } from './core/ole/OleDirectoryEntry.mjs'
@@ -11,6 +11,7 @@ export { AltiumLibraryBatchExporter } from './core/altium/AltiumLibraryBatchExpo
 export { AltiumLibraryRecordBuilder } from './core/altium/AltiumLibraryRecordBuilder.mjs'
 export { AltiumPcbLibExporter } from './core/altium/AltiumPcbLibExporter.mjs'
 export { AltiumSchLibExporter } from './core/altium/AltiumSchLibExporter.mjs'
+export { AltiumUnits } from './core/altium/AltiumUnits.mjs'
 export { SourceBundleExporter } from './core/altium/SourceBundleExporter.mjs'
 export { SourceComponentBundleNormalizer } from './core/altium/SourceComponentBundleNormalizer.mjs'
 export { SourceComponentClient } from './core/altium/SourceComponentClient.mjs'
@@ -20,19 +21,41 @@ export { AsciiRecordParser } from './core/altium/AsciiRecordParser.mjs'
 export { HostCapabilityDiagnosticsBuilder } from './core/altium/HostCapabilityDiagnosticsBuilder.mjs'
 export { IntLibModelParser } from './core/altium/IntLibModelParser.mjs'
 export { IntLibStreamExtractor } from './core/altium/IntLibStreamExtractor.mjs'
+export { EmbeddedAssetReportBuilder } from './core/altium/EmbeddedAssetReportBuilder.mjs'
 export { EmbeddedFileInventoryBuilder } from './core/altium/EmbeddedFileInventoryBuilder.mjs'
+export { FixtureCoverageMatrixBuilder } from './core/altium/FixtureCoverageMatrixBuilder.mjs'
+export { GeometryBoundsReportBuilder } from './core/altium/GeometryBoundsReportBuilder.mjs'
+export {
+    ParameterCollection,
+    ParameterValue
+} from './core/altium/ParameterCollection.mjs'
+export {
+    AltiumFileError,
+    AltiumParseError,
+    AltiumCorruptFileError,
+    AltiumUnsupportedFeatureError
+} from './core/altium/ParserErrors.mjs'
 export { CiArtifactBundleBuilder } from './core/altium/CiArtifactBundleBuilder.mjs'
 export { ContractGateReportBuilder } from './core/altium/ContractGateReportBuilder.mjs'
 export { DraftsmanBoardViewMetadataBuilder } from './core/altium/DraftsmanBoardViewMetadataBuilder.mjs'
 export { DraftsmanDigestParser } from './core/altium/DraftsmanDigestParser.mjs'
 export { LibraryRenderManifestBuilder } from './core/altium/LibraryRenderManifestBuilder.mjs'
+export { LibraryCatalogArtifactBuilder } from './core/altium/LibraryCatalogArtifactBuilder.mjs'
+export { LibraryDiffReportBuilder } from './core/altium/LibraryDiffReportBuilder.mjs'
+export { LibraryInspectionReportBuilder } from './core/altium/LibraryInspectionReportBuilder.mjs'
 export { LibraryQaReportBuilder } from './core/altium/LibraryQaReportBuilder.mjs'
 export { LibrarySearchIndex } from './core/altium/LibrarySearchIndex.mjs'
+export { NativeStreamInventoryBuilder } from './core/altium/NativeStreamInventoryBuilder.mjs'
 export { ParserUtils } from './core/altium/ParserUtils.mjs'
+export { ParameterRecordInventoryBuilder } from './core/altium/ParameterRecordInventoryBuilder.mjs'
 export { ParserCompatibilityFuzzer } from './core/altium/ParserCompatibilityFuzzer.mjs'
+export { ParserDiagnosticNormalizer } from './core/altium/ParserDiagnosticNormalizer.mjs'
+export { ParserFieldCoverageReportBuilder } from './core/altium/ParserFieldCoverageReportBuilder.mjs'
+export { ParserValueVerificationReportBuilder } from './core/altium/ParserValueVerificationReportBuilder.mjs'
 export { NormalizedModelSchema } from './core/altium/NormalizedModelSchema.mjs'
 export { ProjectDesignBundleBuilder } from './core/altium/ProjectDesignBundleBuilder.mjs'
 export { ProjectDocumentGraphBuilder } from './core/altium/ProjectDocumentGraphBuilder.mjs'
+export { ProjectHierarchyReportBuilder } from './core/altium/ProjectHierarchyReportBuilder.mjs'
 export { ProjectAnnotationParser } from './core/altium/ProjectAnnotationParser.mjs'
 export { ProjectNetlistExporter } from './core/altium/ProjectNetlistExporter.mjs'
 export { ProjectVariantViewBuilder } from './core/altium/ProjectVariantViewBuilder.mjs'
@@ -50,6 +73,7 @@ export { PcbEmbeddedModelExtractor } from './core/altium/PcbEmbeddedModelExtract
 export { PcbExtendedPrimitiveInformationParser } from './core/altium/PcbExtendedPrimitiveInformationParser.mjs'
 export { PcbFontMetricsParser } from './core/altium/PcbFontMetricsParser.mjs'
 export { PcbLayerIdCodec } from './core/altium/PcbLayerIdCodec.mjs'
+export { PcbLayerGroups } from './core/altium/PcbLayerGroups.mjs'
 export { PcbLayerStackFidelityReportBuilder } from './core/altium/PcbLayerStackFidelityReportBuilder.mjs'
 export { PcbLayerStackInterchangeParser } from './core/altium/PcbLayerStackInterchangeParser.mjs'
 export { PcbLayerStackQueryHelper } from './core/altium/PcbLayerStackQueryHelper.mjs'
@@ -67,6 +91,9 @@ export { PcbPickPlacePositionResolver } from './core/altium/PcbPickPlacePosition
 export { PcbPolygonRecordParser } from './core/altium/PcbPolygonRecordParser.mjs'
 export { PcbRawRecordRegistry } from './core/altium/PcbRawRecordRegistry.mjs'
 export { PcbReviewMetadataBuilder } from './core/altium/PcbReviewMetadataBuilder.mjs'
+export { PcbClassReportBuilder } from './core/altium/PcbClassReportBuilder.mjs'
+export { PcbInspectionReportBuilder } from './core/altium/PcbInspectionReportBuilder.mjs'
+export { PcbNetMembershipReportBuilder } from './core/altium/PcbNetMembershipReportBuilder.mjs'
 export { PcbRouteAnalysisBuilder } from './core/altium/PcbRouteAnalysisBuilder.mjs'
 export { PcbRuleParser } from './core/altium/PcbRuleParser.mjs'
 export { PcbSidecarRecordParser } from './core/altium/PcbSidecarRecordParser.mjs'
@@ -80,15 +107,22 @@ export { PrintableTextDecoder } from './core/altium/PrintableTextDecoder.mjs'
 export { PrjPcbModelParser } from './core/altium/PrjPcbModelParser.mjs'
 export { PrjScrModelParser } from './core/altium/PrjScrModelParser.mjs'
 export { ProjectBomPnpReconciliationBuilder } from './core/altium/ProjectBomPnpReconciliationBuilder.mjs'
+export { RawDataPreservationReportBuilder } from './core/altium/RawDataPreservationReportBuilder.mjs'
+export { SchLibModelParser } from './core/altium/SchLibModelParser.mjs'
+export { SchLibStreamExtractor } from './core/altium/SchLibStreamExtractor.mjs'
 export { SchematicMultipartOwnerMatcher } from './core/altium/SchematicMultipartOwnerMatcher.mjs'
 export { SchematicCrossSheetConnectorParser } from './core/altium/SchematicCrossSheetConnectorParser.mjs'
+export { SchematicCodeSymbolParser } from './core/altium/SchematicCodeSymbolParser.mjs'
 export { SchematicHarnessParser } from './core/altium/SchematicHarnessParser.mjs'
 export { SchematicImplementationParser } from './core/altium/SchematicImplementationParser.mjs'
 export { SchematicOwnershipGraphParser } from './core/altium/SchematicOwnershipGraphParser.mjs'
 export { SchematicProjectParameterResolver } from './core/altium/SchematicProjectParameterResolver.mjs'
 export { SchematicQaReportBuilder } from './core/altium/SchematicQaReportBuilder.mjs'
+export { SchematicRecordStreamParser } from './core/altium/SchematicRecordStreamParser.mjs'
 export { SchematicRecordTypeRegistry } from './core/altium/SchematicRecordTypeRegistry.mjs'
 export { SchematicRepeatedChannelParser } from './core/altium/SchematicRepeatedChannelParser.mjs'
 export { SchematicTemplateParser } from './core/altium/SchematicTemplateParser.mjs'
+export { UnsupportedFeatureReportBuilder } from './core/altium/UnsupportedFeatureReportBuilder.mjs'
+export { SchematicTextRunParser } from './core/altium/SchematicTextRunParser.mjs'
 export { SchematicStandaloneCalloutNormalizer } from './core/altium/SchematicStandaloneCalloutNormalizer.mjs'
 export { SvgModelCrossLinkValidator } from './core/altium/SvgModelCrossLinkValidator.mjs'

package/src/renderers.mjs

@@ -9,6 +9,7 @@ export { PcbFootprintPrimitiveSelector } from './ui/PcbFootprintPrimitiveSelecto
 export { PcbInteractionIndex } from './ui/PcbInteractionIndex.mjs'
 export { PcbInteractionItemRegistry } from './ui/PcbInteractionItemRegistry.mjs'
 export { PcbInteractionLayerModel } from './ui/PcbInteractionLayerModel.mjs'
+export { PcbLayerGroups } from './core/altium/PcbLayerGroups.mjs'
 export {
     PcbSideResolvedRenderModel,
     isCopperPrimitive,

package/src/ui/SchematicShapeRenderer.mjs

@@ -711,14 +711,16 @@ export class SchematicShapeRenderer {
             arc.startAngle,
             sheetHeight,
             radiusX,
-            radiusY
+            radiusY,
+            true
         )
         const end = SchematicShapeRenderer.#projectArcPoint(
             arc,
             arc.endAngle,
             sheetHeight,
             radiusX,
-            radiusY
+            radiusY,
+            true
         )
 
         return (
@@ -758,14 +760,16 @@ export class SchematicShapeRenderer {
             startAngle,
             sheetHeight,
             radiusX,
-            radiusY
+            radiusY,
+            true
         )
         const mid = SchematicShapeRenderer.#projectArcPoint(
             arc,
             midAngle,
             sheetHeight,
             radiusX,
-            radiusY
+            radiusY,
+            true
         )
 
         return (
@@ -803,10 +807,25 @@ export class SchematicShapeRenderer {
      * @param {number} sheetHeight
      * @param {number} radiusX
      * @param {number} radiusY
+     * @param {boolean} [convertEllipseAngle]
      * @returns {{ x: number, y: number }}
      */
-    static #projectArcPoint(arc, angle, sheetHeight, radiusX, radiusY) {
-        const radians = (Number(angle) * Math.PI) / 180
+    static #projectArcPoint(
+        arc,
+        angle,
+        sheetHeight,
+        radiusX,
+        radiusY,
+        convertEllipseAngle = false
+    ) {
+        const projectedAngle = convertEllipseAngle
+            ? SchematicShapeRenderer.#projectEllipticalArcAngle(
+                  angle,
+                  radiusX,
+                  radiusY
+              )
+            : Number(angle)
+        const radians = (projectedAngle * Math.PI) / 180
 
         return {
             x: Number(arc.x) + radiusX * Math.cos(radians),
@@ -817,6 +836,30 @@ export class SchematicShapeRenderer {
         }
     }
 
+    /**
+     * Converts an authored physical ellipse angle into an SVG parametric
+     * ellipse angle.
+     * @param {number} angle Source angle in degrees.
+     * @param {number} radiusX Horizontal radius.
+     * @param {number} radiusY Vertical radius.
+     * @returns {number}
+     */
+    static #projectEllipticalArcAngle(angle, radiusX, radiusY) {
+        if (Math.abs(Number(radiusX) - Number(radiusY)) < 0.000001) {
+            return Number(angle)
+        }
+
+        const radians = (Number(angle) * Math.PI) / 180
+        return (
+            (Math.atan2(
+                Number(radiusX) * Math.sin(radians),
+                Number(radiusY) * Math.cos(radians)
+            ) *
+                180) /
+            Math.PI
+        )
+    }
+
     /**
      * Keeps one schematic arc delta inside a single turn.
      * @param {number} startAngle