pptx-angular-viewer 4.24.2 → 4.25.0

package/fesm2022/pptx-angular-viewer-view-overflow-BBD8nZlq.mjs

@@ -1,1418 +0,0 @@
-const DIRECTION_ANGLE = {
-	t: 0,
-	tr: 45,
-	r: 90,
-	br: 135,
-	b: 180,
-	bl: 225,
-	l: 270,
-	tl: 315
-};
-const CARDINAL_VECTORS = {
-	0: {
-		dx: 0,
-		dy: -1
-	},
-	90: {
-		dx: 1,
-		dy: 0
-	},
-	180: {
-		dx: 0,
-		dy: 1
-	},
-	270: {
-		dx: -1,
-		dy: 0
-	}
-};
-function getBevelHighlightDirection(lightRigDirection) {
-	if (!lightRigDirection) return {
-		dx: -1,
-		dy: -1
-	};
-	const angle = DIRECTION_ANGLE[lightRigDirection];
-	if (angle === void 0) return {
-		dx: -1,
-		dy: -1
-	};
-	const bucket = Math.floor(angle / 90) * 90;
-	return CARDINAL_VECTORS[bucket] ?? {
-		dx: -1,
-		dy: -1
-	};
-}
-function isBevelProfileInverted(bevelType) {
-	return bevelType === "softRound";
-}
-const BEVEL_PROFILE_HEIGHT_MAP = {
-	circle: {
-		blurFactor: .35,
-		surfaceScaleFactor: .65,
-		measuredUniform: false
-	},
-	convex: {
-		blurFactor: .18,
-		morphologyFactor: .4,
-		surfaceScaleFactor: .2,
-		measuredUniform: false
-	},
-	softRound: {
-		blurFactor: .25,
-		morphologyFactor: .4,
-		surfaceScaleFactor: .65,
-		measuredUniform: false
-	},
-	relaxedInset: {
-		blurFactor: .35,
-		morphologyFactor: .5,
-		surfaceScaleFactor: 1.5,
-		measuredUniform: false,
-		heightTransferTable: [
-			.671,
-			.958,
-			1,
-			.975,
-			0,
-			.32,
-			.839,
-			.924,
-			.924,
-			.924
-		]
-	},
-	divot: {
-		blurFactor: .18,
-		surfaceScaleFactor: .5,
-		measuredUniform: false
-	},
-	angle: {
-		blurFactor: .35,
-		morphologyFactor: .4,
-		surfaceScaleFactor: .35,
-		measuredUniform: false
-	},
-	cross: {
-		blurFactor: .12,
-		morphologyFactor: .18,
-		surfaceScaleFactor: .2,
-		measuredUniform: false
-	},
-	coolSlant: {
-		blurFactor: .25,
-		morphologyFactor: .06,
-		surfaceScaleFactor: .5,
-		measuredUniform: false
-	},
-	riblet: {
-		blurFactor: .25,
-		surfaceScaleFactor: .5,
-		measuredUniform: false
-	},
-	artDeco: {
-		blurFactor: .18,
-		morphologyFactor: .32,
-		surfaceScaleFactor: .35,
-		measuredUniform: false
-	},
-	slope: {
-		blurFactor: .55,
-		morphologyFactor: .5,
-		surfaceScaleFactor: 1.5,
-		measuredUniform: true,
-		heightTransferTable: [
-			.519,
-			1,
-			.967,
-			.96,
-			0,
-			.426,
-			.1,
-			.96,
-			.96,
-			.96
-		]
-	},
-	hardEdge: {
-		blurFactor: .55,
-		morphologyFactor: .5,
-		surfaceScaleFactor: 1.5,
-		measuredUniform: true,
-		heightTransferTable: [
-			.279,
-			1,
-			.938,
-			.938,
-			0,
-			.04,
-			.793,
-			.938,
-			.938,
-			.938
-		]
-	}
-};
-const DEFAULT_HEIGHT_MAP = {
-	blurFactor: .4,
-	surfaceScaleFactor: .8,
-	measuredUniform: false
-};
-function getBevelProfileHeightMap(bevelType) {
-	return BEVEL_PROFILE_HEIGHT_MAP[bevelType] ?? DEFAULT_HEIGHT_MAP;
-}
-const white = "#ffffff";
-const MATERIAL_LIGHTING = {
-	matte: {
-		diffuseConstant: .9,
-		specularConstant: .02,
-		specularExponent: 4,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	warmMatte: {
-		diffuseConstant: .9,
-		specularConstant: .03,
-		specularExponent: 4,
-		lightingColor: "#fff4e6",
-		surfaceScaleMultiplier: 1
-	},
-	powder: {
-		diffuseConstant: .85,
-		specularConstant: .02,
-		specularExponent: 4,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	translucentPowder: {
-		diffuseConstant: .8,
-		specularConstant: .08,
-		specularExponent: 6,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	plastic: {
-		diffuseConstant: .85,
-		specularConstant: .35,
-		specularExponent: 12,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	clear: {
-		diffuseConstant: .7,
-		specularConstant: .45,
-		specularExponent: 16,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	softEdge: {
-		diffuseConstant: .85,
-		specularConstant: .15,
-		specularExponent: 8,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	dkEdge: {
-		diffuseConstant: .75,
-		specularConstant: .2,
-		specularExponent: 14,
-		lightingColor: "#f0f0f0",
-		surfaceScaleMultiplier: 1
-	},
-	softmetal: {
-		diffuseConstant: .65,
-		specularConstant: .6,
-		specularExponent: 16,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	metal: {
-		diffuseConstant: .75,
-		specularConstant: .5,
-		specularExponent: 16,
-		lightingColor: white,
-		surfaceScaleMultiplier: .35,
-		specularElevationCapDeg: 45
-	},
-	flat: {
-		diffuseConstant: .9,
-		specularConstant: 0,
-		specularExponent: 1,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	legacyMatte: {
-		diffuseConstant: .88,
-		specularConstant: .02,
-		specularExponent: 4,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	legacyPlastic: {
-		diffuseConstant: .82,
-		specularConstant: .3,
-		specularExponent: 10,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	},
-	legacyMetal: {
-		diffuseConstant: .7,
-		specularConstant: .8,
-		specularExponent: 22,
-		lightingColor: white,
-		surfaceScaleMultiplier: .45
-	},
-	legacyWireframe: {
-		diffuseConstant: .9,
-		specularConstant: .05,
-		specularExponent: 6,
-		lightingColor: white,
-		surfaceScaleMultiplier: 1
-	}
-};
-const DEFAULT_MATERIAL = "warmMatte";
-function getMaterialLighting(material) {
-	return MATERIAL_LIGHTING[material ?? DEFAULT_MATERIAL] ?? MATERIAL_LIGHTING[DEFAULT_MATERIAL];
-}
-const LIGHT_RIG_LIGHTING = {
-	flat: {
-		elevationDeg: 90,
-		specularSharpness: .3
-	},
-	legacyFlat1: {
-		elevationDeg: 90,
-		specularSharpness: .3
-	},
-	legacyFlat2: {
-		elevationDeg: 77,
-		specularSharpness: .3
-	},
-	legacyFlat3: {
-		elevationDeg: 90,
-		specularSharpness: .3
-	},
-	legacyFlat4: {
-		elevationDeg: 77,
-		specularSharpness: .3,
-		invertedDirection: true
-	},
-	harsh: {
-		elevationDeg: 89,
-		specularSharpness: 1.6,
-		invertedDirection: true
-	},
-	contrasting: {
-		elevationDeg: 90,
-		specularSharpness: 1.5
-	},
-	legacyHarsh1: {
-		elevationDeg: 90,
-		specularSharpness: 1.5
-	},
-	legacyHarsh2: {
-		elevationDeg: 73,
-		specularSharpness: 1.4
-	},
-	legacyHarsh3: {
-		elevationDeg: 90,
-		specularSharpness: 1.5
-	},
-	legacyHarsh4: {
-		elevationDeg: 73,
-		specularSharpness: 1.4,
-		invertedDirection: true
-	},
-	soft: {
-		elevationDeg: 77,
-		specularSharpness: .6
-	},
-	flood: {
-		elevationDeg: 85,
-		specularSharpness: .7
-	},
-	glow: {
-		elevationDeg: 90,
-		specularSharpness: .5
-	},
-	brightRoom: {
-		elevationDeg: 90,
-		specularSharpness: .65
-	},
-	morning: {
-		elevationDeg: 54,
-		specularSharpness: .75,
-		invertedDirection: true
-	},
-	sunrise: {
-		elevationDeg: 59,
-		specularSharpness: .8,
-		invertedDirection: true
-	},
-	sunset: {
-		elevationDeg: 64,
-		specularSharpness: .8,
-		invertedDirection: true
-	},
-	chilly: {
-		elevationDeg: 62,
-		specularSharpness: .6,
-		invertedDirection: true
-	},
-	freezing: {
-		elevationDeg: 62,
-		specularSharpness: .6,
-		invertedDirection: true
-	},
-	threePt: {
-		elevationDeg: 74,
-		specularSharpness: 1
-	},
-	balanced: {
-		elevationDeg: 88,
-		specularSharpness: .95,
-		invertedDirection: true
-	},
-	twoPt: {
-		elevationDeg: 79,
-		specularSharpness: 1,
-		invertedDirection: true
-	},
-	legacyNormal1: {
-		elevationDeg: 90,
-		specularSharpness: 1
-	},
-	legacyNormal2: {
-		elevationDeg: 75,
-		specularSharpness: 1
-	},
-	legacyNormal3: {
-		elevationDeg: 90,
-		specularSharpness: 1
-	},
-	legacyNormal4: {
-		elevationDeg: 75,
-		specularSharpness: 1,
-		invertedDirection: true
-	}
-};
-const DEFAULT_LIGHT_RIG = {
-	elevationDeg: 45,
-	specularSharpness: 1
-};
-function getLightRigLighting(rigType) {
-	if (!rigType) return DEFAULT_LIGHT_RIG;
-	return LIGHT_RIG_LIGHTING[rigType] ?? DEFAULT_LIGHT_RIG;
-}
-const EMU_PER_PX = 9525;
-const CAMERA_PRESET_MAP = {
-	orthographicFront: {
-		rotateX: 0,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	perspectiveFront: {
-		perspectiveRefPx: 1e3,
-		rotateX: 0,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	perspectiveAbove: {
-		perspectiveRefPx: 1e3,
-		rotateX: 20,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	perspectiveBelow: {
-		perspectiveRefPx: 1e3,
-		rotateX: -20,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	perspectiveLeft: {
-		perspectiveRefPx: 1e3,
-		rotateX: 0,
-		rotateY: -20,
-		rotateZ: 0
-	},
-	perspectiveRight: {
-		perspectiveRefPx: 1e3,
-		rotateX: 0,
-		rotateY: 20,
-		rotateZ: 0
-	},
-	perspectiveAboveLeftFacing: {
-		perspectiveRefPx: 1e3,
-		rotateX: 20,
-		rotateY: -25,
-		rotateZ: 0
-	},
-	perspectiveAboveRightFacing: {
-		perspectiveRefPx: 1e3,
-		rotateX: 20,
-		rotateY: 25,
-		rotateZ: 0
-	},
-	perspectiveContrastingLeftFacing: {
-		perspectiveRefPx: 800,
-		rotateX: 15,
-		rotateY: -30,
-		rotateZ: 0,
-		perspectiveOriginXPct: 93,
-		perspectiveOriginYPct: 0
-	},
-	perspectiveContrastingRightFacing: {
-		perspectiveRefPx: 800,
-		rotateX: 15,
-		rotateY: 30,
-		rotateZ: 0,
-		perspectiveOriginXPct: 7,
-		perspectiveOriginYPct: 0
-	},
-	perspectiveHeroicLeftFacing: {
-		perspectiveRefPx: 600,
-		rotateX: 10,
-		rotateY: -35,
-		rotateZ: 0
-	},
-	perspectiveHeroicRightFacing: {
-		perspectiveRefPx: 600,
-		rotateX: 10,
-		rotateY: 35,
-		rotateZ: 0
-	},
-	perspectiveHeroicExtremeLeftFacing: {
-		perspectiveRefPx: 500,
-		rotateX: 8,
-		rotateY: -45,
-		rotateZ: 0,
-		perspectiveOriginXPct: 32,
-		perspectiveOriginYPct: 42
-	},
-	perspectiveHeroicExtremeRightFacing: {
-		perspectiveRefPx: 500,
-		rotateX: 8,
-		rotateY: 45,
-		rotateZ: 0,
-		perspectiveOriginXPct: 68,
-		perspectiveOriginYPct: 42
-	},
-	perspectiveRelaxed: {
-		perspectiveRefPx: 1200,
-		rotateX: 10,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	perspectiveRelaxedModerately: {
-		perspectiveRefPx: 1400,
-		rotateX: 5,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	isometricLeftDown: {
-		rotateX: -35,
-		rotateY: 45,
-		rotateZ: 0
-	},
-	isometricRightUp: {
-		rotateX: -35,
-		rotateY: -45,
-		rotateZ: 0
-	},
-	isometricLeftUp: {
-		rotateX: 35,
-		rotateY: 45,
-		rotateZ: 0
-	},
-	isometricRightDown: {
-		rotateX: 35,
-		rotateY: -45,
-		rotateZ: 0
-	},
-	isometricTopUp: {
-		rotateX: -55,
-		rotateY: 0,
-		rotateZ: 45
-	},
-	isometricTopDown: {
-		rotateX: -55,
-		rotateY: 0,
-		rotateZ: -45
-	},
-	isometricBottomUp: {
-		rotateX: 55,
-		rotateY: 0,
-		rotateZ: 45
-	},
-	isometricBottomDown: {
-		rotateX: 55,
-		rotateY: 0,
-		rotateZ: -45
-	},
-	isometricOffAxis1Left: {
-		rotateX: -30,
-		rotateY: 30,
-		rotateZ: 0
-	},
-	isometricOffAxis1Right: {
-		rotateX: -30,
-		rotateY: -30,
-		rotateZ: 0
-	},
-	isometricOffAxis1Top: {
-		rotateX: -45,
-		rotateY: 0,
-		rotateZ: 30
-	},
-	isometricOffAxis2Left: {
-		rotateX: -30,
-		rotateY: 20,
-		rotateZ: 0
-	},
-	isometricOffAxis2Right: {
-		rotateX: -30,
-		rotateY: -20,
-		rotateZ: 0
-	},
-	isometricOffAxis2Top: {
-		rotateX: -45,
-		rotateY: 0,
-		rotateZ: -30
-	},
-	isometricOffAxis3Left: {
-		rotateX: -25,
-		rotateY: 35,
-		rotateZ: 0
-	},
-	isometricOffAxis3Right: {
-		rotateX: -25,
-		rotateY: -35,
-		rotateZ: 0
-	},
-	isometricOffAxis3Bottom: {
-		rotateX: 45,
-		rotateY: 0,
-		rotateZ: 30
-	},
-	isometricOffAxis4Left: {
-		rotateX: -25,
-		rotateY: 25,
-		rotateZ: 0
-	},
-	isometricOffAxis4Right: {
-		rotateX: -25,
-		rotateY: -25,
-		rotateZ: 0
-	},
-	isometricOffAxis4Bottom: {
-		rotateX: 45,
-		rotateY: 0,
-		rotateZ: -30
-	},
-	obliqueTopLeft: {
-		perspectiveRefPx: 900,
-		rotateX: -20,
-		rotateY: 20,
-		rotateZ: 0
-	},
-	obliqueTop: {
-		perspectiveRefPx: 900,
-		rotateX: -25,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	obliqueTopRight: {
-		perspectiveRefPx: 900,
-		rotateX: -20,
-		rotateY: -20,
-		rotateZ: 0
-	},
-	obliqueLeft: {
-		perspectiveRefPx: 900,
-		rotateX: 0,
-		rotateY: 25,
-		rotateZ: 0
-	},
-	obliqueRight: {
-		perspectiveRefPx: 900,
-		rotateX: 0,
-		rotateY: -25,
-		rotateZ: 0
-	},
-	obliqueBottomLeft: {
-		perspectiveRefPx: 900,
-		rotateX: 20,
-		rotateY: 20,
-		rotateZ: 0
-	},
-	obliqueBottom: {
-		perspectiveRefPx: 900,
-		rotateX: 25,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	obliqueBottomRight: {
-		perspectiveRefPx: 900,
-		rotateX: 20,
-		rotateY: -20,
-		rotateZ: 0
-	},
-	legacyObliqueTopLeft: {
-		perspectiveRefPx: 900,
-		rotateX: -20,
-		rotateY: 20,
-		rotateZ: 0
-	},
-	legacyObliqueTop: {
-		perspectiveRefPx: 900,
-		rotateX: -25,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	legacyObliqueTopRight: {
-		perspectiveRefPx: 900,
-		rotateX: -20,
-		rotateY: -20,
-		rotateZ: 0
-	},
-	legacyObliqueLeft: {
-		perspectiveRefPx: 900,
-		rotateX: 0,
-		rotateY: 25,
-		rotateZ: 0
-	},
-	legacyObliqueFront: {
-		perspectiveRefPx: 900,
-		rotateX: 0,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	legacyObliqueRight: {
-		perspectiveRefPx: 900,
-		rotateX: 0,
-		rotateY: -25,
-		rotateZ: 0
-	},
-	legacyObliqueBottomLeft: {
-		perspectiveRefPx: 900,
-		rotateX: 20,
-		rotateY: 20,
-		rotateZ: 0
-	},
-	legacyObliqueBottom: {
-		perspectiveRefPx: 900,
-		rotateX: 25,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	legacyObliqueBottomRight: {
-		perspectiveRefPx: 900,
-		rotateX: 20,
-		rotateY: -20,
-		rotateZ: 0
-	},
-	legacyPerspectiveTopLeft: {
-		perspectiveRefPx: 700,
-		rotateX: -30,
-		rotateY: 30,
-		rotateZ: 0
-	},
-	legacyPerspectiveTop: {
-		perspectiveRefPx: 700,
-		rotateX: -35,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	legacyPerspectiveTopRight: {
-		perspectiveRefPx: 700,
-		rotateX: -30,
-		rotateY: -30,
-		rotateZ: 0
-	},
-	legacyPerspectiveLeft: {
-		perspectiveRefPx: 700,
-		rotateX: 0,
-		rotateY: 35,
-		rotateZ: 0
-	},
-	legacyPerspectiveFront: {
-		perspectiveRefPx: 700,
-		rotateX: 0,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	legacyPerspectiveRight: {
-		perspectiveRefPx: 700,
-		rotateX: 0,
-		rotateY: -35,
-		rotateZ: 0
-	},
-	legacyPerspectiveBottomLeft: {
-		perspectiveRefPx: 700,
-		rotateX: 30,
-		rotateY: 30,
-		rotateZ: 0
-	},
-	legacyPerspectiveBottom: {
-		perspectiveRefPx: 700,
-		rotateX: 35,
-		rotateY: 0,
-		rotateZ: 0
-	},
-	legacyPerspectiveBottomRight: {
-		perspectiveRefPx: 700,
-		rotateX: 30,
-		rotateY: -30,
-		rotateZ: 0
-	}
-};
-const DEFAULT_PERSPECTIVE_DISTANCE = 6;
-const SCENE_CAMERA_PRESETS = {
-	orthographicFront: {
-		lat: 0,
-		lon: 0,
-		rev: 0
-	},
-	perspectiveFront: {
-		lat: 0,
-		lon: 0,
-		rev: 0,
-		distance: 160
-	},
-	perspectiveLeft: {
-		lat: 0,
-		lon: 20.4,
-		rev: 0,
-		distance: 8.3
-	},
-	perspectiveRight: {
-		lat: 0,
-		lon: -20.4,
-		rev: 0,
-		distance: 8.3
-	},
-	perspectiveRelaxed: {
-		lat: -50.8,
-		lon: .3,
-		rev: -.2,
-		distance: 7.8
-	},
-	perspectiveRelaxedModerately: {
-		lat: -35.1,
-		lon: 0,
-		rev: 0,
-		distance: 7.9
-	},
-	perspectiveHeroicExtremeRightFacing: {
-		lat: 8,
-		lon: -36.1,
-		rev: 2.1,
-		distance: 4.2
-	},
-	perspectiveHeroicExtremeLeftFacing: {
-		lat: 8,
-		lon: 36.1,
-		rev: -2.1,
-		distance: 4.2
-	},
-	isometricOffAxis2Left: {
-		lat: 18,
-		lon: 26,
-		rev: 0
-	},
-	isometricOffAxis2Right: {
-		lat: 18,
-		lon: -26,
-		rev: 0
-	}
-};
-const DEG_PER_UNIT$1 = 6e4;
-function toDeg(value) {
-	return value ? value / DEG_PER_UNIT$1 : 0;
-}
-function normalizeZoom(value) {
-	if (!value || value <= 0) return 1;
-	return value > 10 ? value / 1e5 : value;
-}
-function presetPose(preset) {
-	const fitted = SCENE_CAMERA_PRESETS[preset];
-	if (fitted) return fitted;
-	const legacy = CAMERA_PRESET_MAP[preset];
-	const perspective = preset.startsWith("perspective");
-	return {
-		lat: legacy?.rotateX ?? 0,
-		lon: legacy?.rotateY ?? 0,
-		rev: legacy?.rotateZ ?? 0,
-		...perspective ? { distance: DEFAULT_PERSPECTIVE_DISTANCE } : {}
-	};
-}
-function resolveSmartArt3DCamera(scene) {
-	if (!scene) return;
-	const pose = presetPose(scene.cameraPreset ?? "orthographicFront");
-	const hasRot = scene.cameraRotX !== void 0 || scene.cameraRotY !== void 0 || scene.cameraRotZ !== void 0;
-	const latDeg = hasRot ? toDeg(scene.cameraRotX) : pose.lat;
-	const lonDeg = hasRot ? toDeg(scene.cameraRotY) : pose.lon;
-	const revDeg = hasRot ? toDeg(scene.cameraRotZ) : pose.rev;
-	const distance = pose.distance === void 0 ? void 0 : pose.distance * 192;
-	const zoom = normalizeZoom(scene.cameraZoom);
-	if (latDeg === 0 && lonDeg === 0 && revDeg === 0 && distance === void 0 && zoom === 1) return;
-	return {
-		projection: distance === void 0 ? "orthographic" : "perspective",
-		latDeg,
-		lonDeg,
-		revDeg,
-		distance: distance ?? 0,
-		zoom
-	};
-}
-function smartArt3DCameraMatrix(camera) {
-	const rad = Math.PI / 180;
-	const cl = Math.cos(camera.latDeg * rad);
-	const sl = Math.sin(camera.latDeg * rad);
-	const co = Math.cos(-camera.lonDeg * rad);
-	const so = Math.sin(-camera.lonDeg * rad);
-	const cr = Math.cos(camera.revDeg * rad);
-	const sr = Math.sin(camera.revDeg * rad);
-	const m = [
-		co,
-		0,
-		so,
-		sl * so,
-		cl,
-		-sl * co,
-		-cl * so,
-		sl,
-		cl * co
-	];
-	return [
-		cr * m[0] - sr * m[3],
-		cr * m[1] - sr * m[4],
-		cr * m[2] - sr * m[5],
-		sr * m[0] + cr * m[3],
-		sr * m[1] + cr * m[4],
-		sr * m[2] + cr * m[5],
-		m[6],
-		m[7],
-		m[8]
-	];
-}
-function smartArt3DEyeInDiagram(camera) {
-	if (camera.projection !== "perspective") return;
-	const m = smartArt3DCameraMatrix(camera);
-	return {
-		x: m[6] * camera.distance,
-		y: m[7] * camera.distance,
-		z: m[8] * camera.distance
-	};
-}
-function hasSmartArtShape3D(shape3d) {
-	if (!shape3d) return false;
-	return (shape3d.extrusionHeight ?? 0) > 0 || (shape3d.contourWidth ?? 0) > 0 || (shape3d.bevelTopWidth ?? 0) > 0 || (shape3d.bevelTopHeight ?? 0) > 0 || shape3d.bevelTopType !== void 0 || (shape3d.bevelBottomWidth ?? 0) > 0 || shape3d.bevelBottomType !== void 0;
-}
-function resolveSmartArt3DStylePath(shapes) {
-	if (shapes.some((shape) => shape.scene3d !== void 0)) return "bevel";
-	if (shapes.some((shape) => hasSmartArtShape3D(shape.shape3d))) return "scene";
-	return "flat";
-}
-const DEFAULT_BEVEL_EMU = 76200;
-const MAX_BEVEL_FRACTION = .9;
-function resolveBevel(type, widthEmu, heightEmu, maxWidth) {
-	if (type === void 0 && widthEmu === void 0 && heightEmu === void 0) return;
-	if (type === "none") return;
-	const width = Math.min((widthEmu ?? DEFAULT_BEVEL_EMU) / EMU_PER_PX, maxWidth);
-	const height = (heightEmu ?? DEFAULT_BEVEL_EMU) / EMU_PER_PX;
-	if (width <= 0 || height <= 0) return;
-	return {
-		width,
-		height,
-		profile: type ?? "circle"
-	};
-}
-function resolveSmartArt3DSolid(shape3d, halfExtent) {
-	if (!shape3d || !hasSmartArtShape3D(shape3d)) return;
-	const maxWidth = Math.max(0, halfExtent * MAX_BEVEL_FRACTION);
-	const bevelTop = resolveBevel(shape3d.bevelTopType, shape3d.bevelTopWidth, shape3d.bevelTopHeight, maxWidth);
-	const bevelBottom = resolveBevel(shape3d.bevelBottomType, shape3d.bevelBottomWidth, shape3d.bevelBottomHeight, maxWidth);
-	return {
-		...bevelTop ? { bevelTop } : {},
-		...bevelBottom ? { bevelBottom } : {},
-		extrusion: Math.max(0, (shape3d.extrusionHeight ?? 0) / EMU_PER_PX),
-		...shape3d.extrusionColor ? { extrusionColor: shape3d.extrusionColor } : {},
-		contourWidth: Math.max(0, (shape3d.contourWidth ?? 0) / EMU_PER_PX),
-		...shape3d.contourColor ? { contourColor: shape3d.contourColor } : {},
-		material: shape3d.presetMaterial ?? "warmMatte"
-	};
-}
-const DEFAULT_HIGHLIGHT = [{
-	azimuthDeg: 0,
-	elevationDeg: 60,
-	intensity: 1,
-	sharpness: 1
-}];
-const SMARTART_RIG_SPECULAR_LIGHTS = { threePt: [{
-	azimuthDeg: 64,
-	elevationDeg: 44,
-	intensity: 4.6,
-	sharpness: 3
-}] };
-function smartArt3DRigSpecularLights(rig, perspective) {
-	return (perspective && rig ? SMARTART_RIG_SPECULAR_LIGHTS[rig] : void 0) ?? DEFAULT_HIGHLIGHT;
-}
-const SMARTART_RIG_SCENE_KEY_LIGHTS = {
-	flat: {
-		azimuthDeg: 0,
-		elevationDeg: 40
-	},
-	threePt: {
-		azimuthDeg: 0,
-		elevationDeg: 90
-	},
-	morning: {
-		azimuthDeg: 0,
-		elevationDeg: 60
-	},
-	soft: {
-		azimuthDeg: 0,
-		elevationDeg: 80
-	}
-};
-function smartArt3DRigKeyLight(rig, sceneCamera) {
-	return sceneCamera && rig ? SMARTART_RIG_SCENE_KEY_LIGHTS[rig] : void 0;
-}
-const KEY_ELEVATION_DEG = 5;
-const AMBIENT = .5;
-const SPECULAR_GAIN = .6;
-const VIEW = {
-	x: 0,
-	y: 0,
-	z: 1
-};
-const RIG_REFERENCE_GREY = 127;
-const RIG_FACE_READING = {
-	morning: [
-		112,
-		108,
-		98
-	],
-	soft: [
-		121,
-		121,
-		121
-	]
-};
-function srgbChannelToLinear(c) {
-	return c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
-}
-function rigTint(rig) {
-	const reading = rig ? RIG_FACE_READING[rig] : void 0;
-	if (!reading) return [
-		1,
-		1,
-		1
-	];
-	const reference = srgbChannelToLinear(RIG_REFERENCE_GREY / 255);
-	return reading.map((c) => srgbChannelToLinear(c / 255) / reference);
-}
-function dot(a, b) {
-	return a.x * b.x + a.y * b.y + a.z * b.z;
-}
-function normalize(v) {
-	const len = Math.hypot(v.x, v.y, v.z) || 1;
-	return {
-		x: v.x / len,
-		y: v.y / len,
-		z: v.z / len
-	};
-}
-function resolveSmartArt3DLightModel(lighting, material, perspective = false, sceneCamera = perspective) {
-	const snap = getBevelHighlightDirection(lighting?.direction ?? "t");
-	const rev = (lighting?.revDeg ?? 0) * Math.PI / 180;
-	const ax = snap.dx;
-	const ay = -snap.dy;
-	const az = Math.hypot(ax, ay) || 1;
-	const azX = (ax * Math.cos(rev) - ay * Math.sin(rev)) / az;
-	const azY = (ax * Math.sin(rev) + ay * Math.cos(rev)) / az;
-	const toward = (elevationDeg, azimuthDeg = 0) => {
-		const elevation = elevationDeg * Math.PI / 180;
-		const turn = azimuthDeg * Math.PI / 180;
-		const dx = azX * Math.cos(turn) - azY * Math.sin(turn);
-		const dy = azX * Math.sin(turn) + azY * Math.cos(turn);
-		return normalize({
-			x: dx * Math.cos(elevation),
-			y: dy * Math.cos(elevation),
-			z: Math.sin(elevation)
-		});
-	};
-	const response = getMaterialLighting(material);
-	const specular = response.specularConstant * SPECULAR_GAIN;
-	const key = smartArt3DRigKeyLight(lighting?.rig, sceneCamera);
-	return {
-		light: key ? toward(key.elevationDeg, key.azimuthDeg) : toward(KEY_ELEVATION_DEG),
-		highlights: smartArt3DRigSpecularLights(lighting?.rig, perspective).map((rigLight) => ({
-			direction: toward(rigLight.elevationDeg, rigLight.azimuthDeg),
-			weight: specular * rigLight.intensity,
-			exponent: response.specularExponent * rigLight.sharpness
-		})),
-		ambient: AMBIENT,
-		diffuse: response.diffuseConstant,
-		tint: rigTint(lighting?.rig)
-	};
-}
-function shadeSmartArt3DNormal(normal, model, eye) {
-	const lambert = (n) => model.ambient + model.diffuse * Math.max(0, dot(n, model.light));
-	const mul = lambert(normal) / lambert(VIEW);
-	const view = eye ?? VIEW;
-	let add = 0;
-	for (const highlight of model.highlights) {
-		const half = normalize({
-			x: highlight.direction.x + view.x,
-			y: highlight.direction.y + view.y,
-			z: highlight.direction.z + view.z
-		});
-		const peak = (n) => Math.max(0, dot(n, half)) ** highlight.exponent;
-		add += highlight.weight * Math.max(0, peak(normal) - (eye ? 0 : peak(VIEW)));
-	}
-	return {
-		mul,
-		add
-	};
-}
-function srgbToLinear(c) {
-	return c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
-}
-function hexToRgb(hex) {
-	const match = /^#?([0-9a-f]{6})$/iu.exec(hex.trim());
-	if (!match) return [
-		0,
-		0,
-		0
-	];
-	const n = Number.parseInt(match[1], 16);
-	return [
-		(n >> 16 & 255) / 255,
-		(n >> 8 & 255) / 255,
-		(n & 255) / 255
-	];
-}
-function normalizeVec(v) {
-	const len = Math.hypot(v.x, v.y, v.z) || 1;
-	return {
-		x: v.x / len,
-		y: v.y / len,
-		z: v.z / len
-	};
-}
-const MIN_LINEAR = 1e-4;
-function shadeSmartArt3DVertices(positions, normals, baseAt, model, eye) {
-	const out = new Float32Array(positions.length);
-	for (let i = 0; i < positions.length; i += 3) {
-		const { mul, add } = shadeSmartArt3DNormal({
-			x: normals[i],
-			y: normals[i + 1],
-			z: normals[i + 2]
-		}, model, eye ? normalizeVec({
-			x: eye.x - positions[i],
-			y: eye.y - positions[i + 1],
-			z: eye.z - positions[i + 2]
-		}) : void 0);
-		const base = baseAt({
-			x: positions[i],
-			y: positions[i + 1]
-		});
-		for (let c = 0; c < 3; c++) {
-			const target = Math.min(1, Math.max(0, base[c] * mul + add));
-			const linBase = Math.max(MIN_LINEAR, srgbToLinear(base[c]));
-			out[i + c] = srgbToLinear(target) / linBase * model.tint[c];
-		}
-	}
-	return out;
-}
-const DEG_PER_UNIT = 6e4;
-function percent(value, fallback) {
-	const parsed = value === void 0 ? NaN : Number.parseFloat(value);
-	return Number.isFinite(parsed) ? parsed / 100 : fallback;
-}
-function buildSmartArt3DGradient(rendered, toLocal) {
-	const gradient = rendered.gradient;
-	if (!gradient || gradient.stops.length === 0) return;
-	const at = (fx, fy) => toLocal({
-		x: rendered.x + fx * rendered.width,
-		y: rendered.y + fy * rendered.height
-	});
-	const stops = gradient.stops.map((stop) => ({
-		offset: Math.max(0, Math.min(1, percent(stop.offset, 0))),
-		color: stop.color
-	}));
-	if (gradient.kind === "radial") {
-		const cx = percent(gradient.cx, .5);
-		const cy = percent(gradient.cy, .5);
-		const r = percent(gradient.r, .5);
-		return {
-			kind: "radial",
-			from: at(cx, cy),
-			to: at(cx + r, cy),
-			stops
-		};
-	}
-	return {
-		kind: "linear",
-		from: at(percent(gradient.x1, 0), percent(gradient.y1, 0)),
-		to: at(percent(gradient.x2, 1), percent(gradient.y2, 0)),
-		stops
-	};
-}
-function smartArt3DGradientCoordinate(p, gradient) {
-	const dx = gradient.to.x - gradient.from.x;
-	const dy = gradient.to.y - gradient.from.y;
-	const lengthSq = dx * dx + dy * dy;
-	if (lengthSq <= 0) return 0;
-	const u = gradient.kind === "radial" ? Math.hypot(p.x - gradient.from.x, p.y - gradient.from.y) / Math.sqrt(lengthSq) : ((p.x - gradient.from.x) * dx + (p.y - gradient.from.y) * dy) / lengthSq;
-	return Math.max(0, Math.min(1, u));
-}
-function smartArt3DGradientColor(gradient, p) {
-	const u = smartArt3DGradientCoordinate(p, gradient);
-	const stops = gradient.stops;
-	if (u <= stops[0].offset) return hexToRgb(stops[0].color);
-	for (let i = 1; i < stops.length; i++) {
-		const b = stops[i];
-		if (u <= b.offset) {
-			const a = stops[i - 1];
-			const span = b.offset - a.offset;
-			const f = span > 0 ? (u - a.offset) / span : 1;
-			const ca = hexToRgb(a.color);
-			const cb = hexToRgb(b.color);
-			return [
-				ca[0] + (cb[0] - ca[0]) * f,
-				ca[1] + (cb[1] - ca[1]) * f,
-				ca[2] + (cb[2] - ca[2]) * f
-			];
-		}
-	}
-	return hexToRgb(stops[stops.length - 1].color);
-}
-function decorateSmartArt3DMesh(mesh, shape, rendered, toLocal) {
-	mesh.flat = false;
-	const solid = resolveSmartArt3DSolid(shape.shape3d, Math.min(rendered.width, rendered.height) / 2);
-	if (solid) mesh.solid = solid;
-	const textExtrusion = (shape.text3d?.extrusionHeight ?? 0) / EMU_PER_PX;
-	if (mesh.textBlock && textExtrusion > 0) {
-		mesh.textBlock.extrusion = textExtrusion;
-		if (shape.text3d?.extrusionColor) mesh.textBlock.extrusionColor = shape.text3d.extrusionColor;
-	}
-	const gradient = buildSmartArt3DGradient(rendered, toLocal);
-	if (gradient) mesh.gradient = gradient;
-}
-function resolveSmartArt3DSceneSetup(data, category) {
-	if (category === "flat") return {};
-	const diagramScene = data.quickStyle?.scene3d;
-	const rigScene = category === "bevel" ? data.drawingShapes?.find((s) => s.scene3d?.lightRigType)?.scene3d ?? diagramScene : diagramScene;
-	const lighting = {
-		rig: rigScene?.lightRigType ?? "threePt",
-		direction: rigScene?.lightRigDirection ?? "t",
-		revDeg: (rigScene?.lightRigRotZ ?? 0) / DEG_PER_UNIT
-	};
-	const camera = category === "scene" ? resolveSmartArt3DCamera(diagramScene) : void 0;
-	return {
-		lighting,
-		...camera ? { camera } : {}
-	};
-}
-const MAX_VIEW_PIXELS = 4096;
-function createRenderer(three, state) {
-	try {
-		const renderer = new three.WebGLRenderer({
-			antialias: true,
-			alpha: true,
-			premultipliedAlpha: true,
-			powerPreference: "default"
-		});
-		renderer.setPixelRatio(1);
-		renderer.outputColorSpace = three.SRGBColorSpace;
-		renderer.autoClear = false;
-		const canvas = renderer.domElement;
-		canvas.addEventListener("webglcontextlost", (event) => {
-			event.preventDefault();
-			state.lost = true;
-		});
-		canvas.addEventListener("webglcontextrestored", () => {
-			state.lost = false;
-			for (const view of state.views) state.dirty.add(view);
-			schedule(state);
-		});
-		return renderer;
-	} catch {
-		return null;
-	}
-}
-function ensureBuffer(state, width, height) {
-	const renderer = state.renderer;
-	if (!renderer || width <= state.bufferWidth && height <= state.bufferHeight) return;
-	state.bufferWidth = Math.min(MAX_VIEW_PIXELS, Math.max(state.bufferWidth, width));
-	state.bufferHeight = Math.min(MAX_VIEW_PIXELS, Math.max(state.bufferHeight, height));
-	renderer.setSize(state.bufferWidth, state.bufferHeight, false);
-}
-function drawView(state, view) {
-	const renderer = state.renderer;
-	if (!renderer) return;
-	const size = view.pixelSize();
-	const width = Math.max(1, Math.min(MAX_VIEW_PIXELS, Math.round(size.width)));
-	const height = Math.max(1, Math.min(MAX_VIEW_PIXELS, Math.round(size.height)));
-	ensureBuffer(state, width, height);
-	const y = state.bufferHeight - height;
-	renderer.setViewport(0, y, width, height);
-	renderer.setScissor(0, y, width, height);
-	renderer.setScissorTest(true);
-	renderer.setClearColor(0, 0);
-	renderer.clear(true, true, true);
-	view.draw(renderer);
-	const target = view.canvas;
-	if (target.width !== width || target.height !== height) {
-		target.width = width;
-		target.height = height;
-	}
-	const ctx = target.getContext("2d");
-	if (!ctx) return;
-	ctx.clearRect(0, 0, width, height);
-	ctx.drawImage(renderer.domElement, 0, 0, width, height, 0, 0, width, height);
-}
-function flush(state) {
-	state.frame = 0;
-	if (state.lost || !state.renderer) return;
-	const pending = [...state.dirty];
-	state.dirty.clear();
-	for (const view of pending) {
-		if (!state.views.has(view)) continue;
-		if (!view.isVisible()) {
-			state.dirty.add(view);
-			continue;
-		}
-		try {
-			drawView(state, view);
-		} catch (error) {
-			console.error("[pptx-three-view] scene render failed", error);
-			continue;
-		}
-		if (view.isAnimating()) state.dirty.add(view);
-	}
-	if ([...state.dirty].some((v) => v.isVisible())) schedule(state);
-}
-function schedule(state) {
-	if (state.frame !== 0 || typeof requestAnimationFrame === "undefined") return;
-	state.frame = requestAnimationFrame(() => flush(state));
-}
-let sharedHost = null;
-function getThreeRendererHost(three) {
-	if (sharedHost) return sharedHost;
-	const state = {
-		three,
-		renderer: null,
-		views: /* @__PURE__ */ new Set(),
-		dirty: /* @__PURE__ */ new Set(),
-		frame: 0,
-		lost: false,
-		bufferWidth: 0,
-		bufferHeight: 0
-	};
-	state.renderer = createRenderer(three, state);
-	const host = {
-		available: state.renderer !== null,
-		register(view) {
-			state.views.add(view);
-			state.dirty.add(view);
-			schedule(state);
-		},
-		unregister(view) {
-			state.views.delete(view);
-			state.dirty.delete(view);
-		},
-		requestRender(view) {
-			if (!state.views.has(view)) return;
-			state.dirty.add(view);
-			schedule(state);
-		},
-		flushNow() {
-			if (state.frame !== 0 && typeof cancelAnimationFrame !== "undefined") cancelAnimationFrame(state.frame);
-			flush(state);
-		},
-		drawNow(view) {
-			if (state.lost || !state.renderer || !state.views.has(view)) return;
-			state.dirty.delete(view);
-			try {
-				drawView(state, view);
-			} catch (error) {
-				console.error("[pptx-three-view] scene render failed", error);
-			}
-		}
-	};
-	sharedHost = host;
-	return host;
-}
-const MAX_THREE_VIEW_OVERFLOW = .5;
-const OVERFLOW_MARGIN = .01;
-const NO_THREE_VIEW_OVERFLOW = {
-	top: 0,
-	right: 0,
-	bottom: 0,
-	left: 0
-};
-function side(reach) {
-	if (!(reach > 0)) return 0;
-	return Math.min(MAX_THREE_VIEW_OVERFLOW, reach + OVERFLOW_MARGIN);
-}
-function threeViewOverflowFromNdc(points) {
-	if (points.length === 0) return NO_THREE_VIEW_OVERFLOW;
-	let minX = Infinity;
-	let maxX = -Infinity;
-	let minY = Infinity;
-	let maxY = -Infinity;
-	for (const p of points) {
-		if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) continue;
-		minX = Math.min(minX, p.x);
-		maxX = Math.max(maxX, p.x);
-		minY = Math.min(minY, p.y);
-		maxY = Math.max(maxY, p.y);
-	}
-	if (minX > maxX) return NO_THREE_VIEW_OVERFLOW;
-	return {
-		top: side((maxY - 1) / 2),
-		right: side((maxX - 1) / 2),
-		bottom: side((-1 - minY) / 2),
-		left: side((-1 - minX) / 2)
-	};
-}
-function hasThreeViewOverflow(overflow) {
-	return Boolean(overflow && (overflow.top > 0 || overflow.right > 0 || overflow.bottom > 0 || overflow.left > 0));
-}
-function threeViewOverflowChanged(a, b) {
-	return a.top !== b.top || a.right !== b.right || a.bottom !== b.bottom || a.left !== b.left;
-}
-function overflowPixelSize(size, overflow) {
-	const clamp = (px) => Math.max(1, Math.min(MAX_VIEW_PIXELS, Math.round(px)));
-	return {
-		width: clamp(size.pixelWidth * (1 + overflow.left + overflow.right)),
-		height: clamp(size.pixelHeight * (1 + overflow.top + overflow.bottom))
-	};
-}
-function overflowViewOffset(size, overflow) {
-	const fullWidth = Math.max(1, size.pixelWidth);
-	const fullHeight = Math.max(1, size.pixelHeight);
-	return {
-		fullWidth,
-		fullHeight,
-		x: -overflow.left * fullWidth,
-		y: -overflow.top * fullHeight,
-		width: fullWidth * (1 + overflow.left + overflow.right),
-		height: fullHeight * (1 + overflow.top + overflow.bottom)
-	};
-}
-function overflowCanvasCss(overflow) {
-	if (!hasThreeViewOverflow(overflow)) return "";
-	const pct = (v) => `${Number((v * 100).toFixed(4))}%`;
-	return [
-		`left:${pct(-overflow.left)}`,
-		`top:${pct(-overflow.top)}`,
-		`width:${pct(1 + overflow.left + overflow.right)}`,
-		`height:${pct(1 + overflow.top + overflow.bottom)}`
-	].join(";");
-}
-export { getMaterialLighting as C, isBevelProfileInverted as E, getLightRigLighting as S, getBevelHighlightDirection as T, resolveSmartArt3DStylePath as _, overflowViewOffset as a, CAMERA_PRESET_MAP as b, MAX_VIEW_PIXELS as c, resolveSmartArt3DSceneSetup as d, smartArt3DGradientColor as f, resolveSmartArt3DLightModel as g, shadeSmartArt3DVertices as h, overflowPixelSize as i, getThreeRendererHost as l, hexToRgb as m, hasThreeViewOverflow as n, threeViewOverflowChanged as o, smartArt3DGradientCoordinate as p, overflowCanvasCss as r, threeViewOverflowFromNdc as s, NO_THREE_VIEW_OVERFLOW as t, decorateSmartArt3DMesh as u, smartArt3DCameraMatrix as v, getBevelProfileHeightMap as w, EMU_PER_PX as x, smartArt3DEyeInDiagram as y };
-
-//# sourceMappingURL=pptx-angular-viewer-view-overflow-BBD8nZlq.mjs.map