@bendyline/squisq 1.4.1 → 1.5.1

package/dist/chunk-PGGGKYWG.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-PGGGKYWG.js.map

package/dist/chunk-PGGGKYWG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{chunk-7UDSRZKG.js → chunk-Q3ROPT5H.js}

@@ -38,9 +38,7 @@ function getNeighbors(hash) {
   return ngeohash.neighbors(hash);
 }
 function getGeohash4Neighbors(geohash4) {
-  if (geohash4.length !== 4) {
-    throw new Error(`getGeohash4Neighbors requires 4-char geohash, got: ${geohash4}`);
-  }
+  if (geohash4.length !== 4) return [];
   const neighbors = getNeighbors(geohash4);
   return [geohash4, ...neighbors];
 }
@@ -48,9 +46,7 @@ function getGeohashPrefix(geohash, precision) {
   return geohash.slice(0, precision);
 }
 function geohashToHierarchicalPath(geohash4) {
-  if (geohash4.length !== 4) {
-    throw new Error(`geohashToHierarchicalPath requires 4-char geohash, got: ${geohash4}`);
-  }
+  if (geohash4.length !== 4) return "";
   const [c1, c2, c3, c4] = geohash4.split("");
   return `${c1}/${c2}/${c3}/${c4}`;
 }
@@ -58,19 +54,44 @@ function getGeohashPath(from, to, precision = 4) {
   if (from === to) return [];
   const fromCenter = decodeGeohash(from);
   const toCenter = decodeGeohash(to);
-  const dLat = Math.abs(toCenter.lat - fromCenter.lat);
-  const dLng = Math.abs(toCenter.lng - fromCenter.lng);
-  const midLatRad = (fromCenter.lat + toCenter.lat) / 2 * (Math.PI / 180);
-  const approxKm = Math.sqrt((dLat * 111) ** 2 + (dLng * 111 * Math.cos(midLatRad)) ** 2);
-  const steps = Math.max(2, Math.ceil(approxKm / 15));
+  const distKm = haversineDistance(
+    { lat: fromCenter.lat, lng: fromCenter.lng },
+    { lat: toCenter.lat, lng: toCenter.lng }
+  );
+  const steps = Math.max(2, Math.ceil(distKm / 15));
+  const \u03C61 = fromCenter.lat * Math.PI / 180;
+  const \u03BB1 = fromCenter.lng * Math.PI / 180;
+  const \u03C62 = toCenter.lat * Math.PI / 180;
+  const \u03BB2 = toCenter.lng * Math.PI / 180;
+  const x1 = Math.cos(\u03C61) * Math.cos(\u03BB1);
+  const y1 = Math.cos(\u03C61) * Math.sin(\u03BB1);
+  const z1 = Math.sin(\u03C61);
+  const x2 = Math.cos(\u03C62) * Math.cos(\u03BB2);
+  const y2 = Math.cos(\u03C62) * Math.sin(\u03BB2);
+  const z2 = Math.sin(\u03C62);
+  const dot = Math.max(-1, Math.min(1, x1 * x2 + y1 * y2 + z1 * z2));
+  const d = Math.acos(dot);
+  const useLinear = Math.abs(Math.sin(d)) < 1e-10;
   const seen = /* @__PURE__ */ new Set();
   seen.add(from);
   seen.add(to);
   const path = [];
   for (let i = 1; i < steps; i++) {
     const t = i / steps;
-    const lat = fromCenter.lat + t * (toCenter.lat - fromCenter.lat);
-    const lng = fromCenter.lng + t * (toCenter.lng - fromCenter.lng);
+    let lat;
+    let lng;
+    if (useLinear) {
+      lat = fromCenter.lat + t * (toCenter.lat - fromCenter.lat);
+      lng = fromCenter.lng + t * (toCenter.lng - fromCenter.lng);
+    } else {
+      const A = Math.sin((1 - t) * d) / Math.sin(d);
+      const B = Math.sin(t * d) / Math.sin(d);
+      const x = A * x1 + B * x2;
+      const y = A * y1 + B * y2;
+      const z = A * z1 + B * z2;
+      lat = Math.atan2(z, Math.sqrt(x * x + y * y)) * 180 / Math.PI;
+      lng = Math.atan2(y, x) * 180 / Math.PI;
+    }
     const hash = encodeGeohash(lat, lng, precision);
     if (!seen.has(hash)) {
       seen.add(hash);
@@ -100,4 +121,4 @@ export {
   getGeohashPath,
   geohashOverlapsBounds
 };
-//# sourceMappingURL=chunk-7UDSRZKG.js.map
+//# sourceMappingURL=chunk-Q3ROPT5H.js.map

package/dist/chunk-Q3ROPT5H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/spatial/Haversine.ts","../src/spatial/Geohash.ts"],"sourcesContent":["/**\n * Haversine Distance Calculation\n *\n * Provides accurate distance calculation between two geographic coordinates\n * using the Haversine formula, which accounts for Earth's curvature.\n */\n\nimport type { Coordinates } from '../schemas/Types.js';\n\n/**\n * Calculate distance between two coordinates using Haversine formula.\n *\n * @param from Start coordinates\n * @param to End coordinates\n * @returns Distance in kilometers\n */\nexport function haversineDistance(from: Coordinates, to: Coordinates): number {\n  const R = 6371; // Earth's radius in kilometers\n\n  const dLat = toRadians(to.lat - from.lat);\n  const dLng = toRadians(to.lng - from.lng);\n\n  const a =\n    Math.sin(dLat / 2) * Math.sin(dLat / 2) +\n    Math.cos(toRadians(from.lat)) *\n      Math.cos(toRadians(to.lat)) *\n      Math.sin(dLng / 2) *\n      Math.sin(dLng / 2);\n\n  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n\n  return R * c;\n}\n\n/**\n * Calculate bearing from one coordinate to another.\n *\n * @param from Start coordinates\n * @param to End coordinates\n * @returns Bearing in degrees (0-360, where 0 = north, 90 = east)\n */\nexport function calculateBearing(from: Coordinates, to: Coordinates): number {\n  const dLng = toRadians(to.lng - from.lng);\n  const lat1 = toRadians(from.lat);\n  const lat2 = toRadians(to.lat);\n\n  const x = Math.sin(dLng) * Math.cos(lat2);\n  const y = Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLng);\n\n  const bearing = Math.atan2(x, y);\n  return ((bearing * 180) / Math.PI + 360) % 360;\n}\n\n/**\n * Convert degrees to radians.\n */\nfunction toRadians(degrees: number): number {\n  return (degrees * Math.PI) / 180;\n}\n","/**\n * Geohash Utilities\n *\n * Provides geohash encoding/decoding and spatial utilities using the standard\n * ngeohash library for core operations, plus custom utilities for overlap checking\n * and distance calculation.\n *\n * Geohashes are a hierarchical spatial indexing system that divides the world\n * into a grid of cells. Each additional character narrows the area by ~1/32.\n *\n * Precision guide:\n * - 4 chars: ~39km x 19km (used for tile indexing)\n * - 5 chars: ~5km x 5km\n * - 6 chars: ~1.2km x 0.6km\n */\n\nimport ngeohash from 'ngeohash';\nimport { haversineDistance } from './Haversine.js';\n\n/**\n * Encode latitude/longitude to a geohash string.\n * Uses the standard ngeohash library.\n */\nexport function encodeGeohash(lat: number, lng: number, precision = 9): string {\n  return ngeohash.encode(lat, lng, precision);\n}\n\n/**\n * Decode a geohash to latitude/longitude center with error bounds.\n * Uses the standard ngeohash library.\n */\nexport function decodeGeohash(hash: string): {\n  lat: number;\n  lng: number;\n  latErr: number;\n  lngErr: number;\n} {\n  const result = ngeohash.decode(hash);\n  return {\n    lat: result.latitude,\n    lng: result.longitude,\n    latErr: result.error.latitude,\n    lngErr: result.error.longitude,\n  };\n}\n\n/**\n * Get the 8 neighboring geohash cells.\n * Returns up to 8 neighbors (fewer at poles or antimeridian).\n * Uses the standard ngeohash library.\n */\nexport function getNeighbors(hash: string): string[] {\n  return ngeohash.neighbors(hash);\n}\n\n/**\n * Get a 3x3 grid of geohash4 cells (center + 8 neighbors).\n * Used for landing bonus expansions in Fly mode.\n *\n * @param geohash4 - Center geohash4 cell\n * @returns Array of 9 geohash4 cells (center first, then neighbors)\n *\n * @example\n * getGeohash4Neighbors('c23n')\n * // => ['c23n', 'c23p', 'c23q', 'c23j', 'c23m', 'c23k', 'c23h', 'c23e', 'c23s']\n */\nexport function getGeohash4Neighbors(geohash4: string): string[] {\n  if (geohash4.length !== 4) return [];\n  const neighbors = getNeighbors(geohash4);\n  return [geohash4, ...neighbors];\n}\n\n/**\n * Get the prefix of a geohash at a given precision.\n * Simple helper for extracting geohash prefixes for directory organization.\n */\nexport function getGeohashPrefix(geohash: string, precision: number): string {\n  return geohash.slice(0, precision);\n}\n\n/**\n * Convert a geohash prefix to a hierarchical path.\n *\n * Examples:\n *   \"9mud\" -> \"9/m/u/d\"\n *   \"9q8y\" -> \"9/q/8/y\"\n *   \"c24k\" -> \"c/2/4/k\"\n *\n * This is used for organizing files in hierarchical directories to avoid\n * thousands of folders in a single directory, which causes filesystem\n * performance issues.\n */\nexport function geohashToHierarchicalPath(geohash4: string): string {\n  if (geohash4.length !== 4) return '';\n  const [c1, c2, c3, c4] = geohash4.split('');\n  return `${c1}/${c2}/${c3}/${c4}`;\n}\n\n/**\n * Compute all geohash cells along the great-circle path between two geohash cells.\n * Samples points along the spherical arc from `from` to `to`, encoding each to a\n * geohash at the given precision, and returns the deduplicated list of intermediate\n * cells (excluding `from` and `to`).\n *\n * Uses spherical linear interpolation (SLERP) via 3D unit vectors, which correctly\n * handles antimeridian crossings and polar paths — both of which flat lat/lng\n * interpolation gets wrong.\n */\nexport function getGeohashPath(from: string, to: string, precision = 4): string[] {\n  if (from === to) return [];\n\n  const fromCenter = decodeGeohash(from);\n  const toCenter = decodeGeohash(to);\n\n  // Use haversine for accurate great-circle distance (step sizing)\n  const distKm = haversineDistance(\n    { lat: fromCenter.lat, lng: fromCenter.lng },\n    { lat: toCenter.lat, lng: toCenter.lng },\n  );\n\n  // Step every ~15km to avoid skipping any geohash4 cell (~39x19km)\n  const steps = Math.max(2, Math.ceil(distKm / 15));\n\n  // Convert endpoints to unit Cartesian vectors for SLERP\n  const φ1 = (fromCenter.lat * Math.PI) / 180;\n  const λ1 = (fromCenter.lng * Math.PI) / 180;\n  const φ2 = (toCenter.lat * Math.PI) / 180;\n  const λ2 = (toCenter.lng * Math.PI) / 180;\n\n  const x1 = Math.cos(φ1) * Math.cos(λ1);\n  const y1 = Math.cos(φ1) * Math.sin(λ1);\n  const z1 = Math.sin(φ1);\n  const x2 = Math.cos(φ2) * Math.cos(λ2);\n  const y2 = Math.cos(φ2) * Math.sin(λ2);\n  const z2 = Math.sin(φ2);\n\n  // Central angle between the two points\n  const dot = Math.max(-1, Math.min(1, x1 * x2 + y1 * y2 + z1 * z2));\n  const d = Math.acos(dot);\n  // Near-antipodal fallback: sin(d)≈0 means the great circle is undefined.\n  // Extremely unlikely for geohash path use; fall back to linear lat/lng.\n  const useLinear = Math.abs(Math.sin(d)) < 1e-10;\n\n  const seen = new Set<string>();\n  seen.add(from);\n  seen.add(to);\n\n  const path: string[] = [];\n  for (let i = 1; i < steps; i++) {\n    const t = i / steps;\n    let lat: number;\n    let lng: number;\n    if (useLinear) {\n      lat = fromCenter.lat + t * (toCenter.lat - fromCenter.lat);\n      lng = fromCenter.lng + t * (toCenter.lng - fromCenter.lng);\n    } else {\n      const A = Math.sin((1 - t) * d) / Math.sin(d);\n      const B = Math.sin(t * d) / Math.sin(d);\n      const x = A * x1 + B * x2;\n      const y = A * y1 + B * y2;\n      const z = A * z1 + B * z2;\n      lat = (Math.atan2(z, Math.sqrt(x * x + y * y)) * 180) / Math.PI;\n      lng = (Math.atan2(y, x) * 180) / Math.PI;\n    }\n    const hash = encodeGeohash(lat, lng, precision);\n    if (!seen.has(hash)) {\n      seen.add(hash);\n      path.push(hash);\n    }\n  }\n\n  return path;\n}\n\n/**\n * Check if a geohash cell overlaps with a bounding box.\n * Custom implementation (not available in ngeohash).\n */\nexport function geohashOverlapsBounds(\n  hash: string,\n  bounds: { north: number; south: number; east: number; west: number },\n): boolean {\n  const { lat, lng, latErr, lngErr } = decodeGeohash(hash);\n\n  const hashNorth = lat + latErr;\n  const hashSouth = lat - latErr;\n  const hashEast = lng + lngErr;\n  const hashWest = lng - lngErr;\n\n  return !(\n    hashNorth < bounds.south ||\n    hashSouth > bounds.north ||\n    hashEast < bounds.west ||\n    hashWest > bounds.east\n  );\n}\n\n// Re-export for backwards compatibility with existing imports.\nexport { haversineDistance };\n"],"mappings":"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","names":[]}

package/dist/chunk-QE7TWGVT.js

@@ -0,0 +1,178 @@
+// src/schemas/Transitions.ts
+var DEFAULT_TRANSITION_DURATION_SECONDS = 0.7;
+var TRANSITION_TYPES = [
+  // Existing / common transitions
+  "cut",
+  "fade",
+  "dissolve",
+  "push",
+  "wipe",
+  "split",
+  "reveal",
+  "randomBars",
+  "shape",
+  "uncover",
+  "cover",
+  "zoom",
+  "pan",
+  // PowerPoint subtle / exciting transitions
+  "flash",
+  "fallOver",
+  "drape",
+  "curtains",
+  "wind",
+  "prestige",
+  "fracture",
+  "crush",
+  "peelOff",
+  "pageCurl",
+  "airplane",
+  "origami",
+  "checkerboard",
+  "blinds",
+  "clock",
+  "ripple",
+  "honeycomb",
+  "glitter",
+  "vortex",
+  "shred",
+  "switch",
+  "flip",
+  "gallery",
+  "cube",
+  "doors",
+  "box",
+  "ferrisWheel",
+  "conveyor",
+  "rotate",
+  "window",
+  "orbit",
+  "flyThrough",
+  "morph",
+  // PresentationML/Open XML precise names and legacy aliases
+  "checker",
+  "circle",
+  "comb",
+  "diamond",
+  "newsflash",
+  "plus",
+  "pull",
+  "random",
+  "randomBar",
+  "strips",
+  "wedge",
+  "wheel",
+  "prism",
+  "warp",
+  "ferris",
+  "flythrough",
+  "wheelReverse",
+  "pageCurlDouble",
+  "pageCurlSingle",
+  "slideLeft",
+  "slideRight",
+  "slideUp",
+  "slideDown"
+];
+var TRANSITION_DIRECTIONS = [
+  "left",
+  "right",
+  "up",
+  "down",
+  "in",
+  "out",
+  "horizontal",
+  "vertical"
+];
+var TRANSITION_TYPE_SET = new Set(TRANSITION_TYPES);
+var TRANSITION_TYPE_ALIASES = {
+  none: "cut",
+  randombars: "randomBars",
+  randombar: "randomBar",
+  // Self-referential spellings (`checkerboard`, `shape`, `uncover`) are
+  // intentionally absent: an exact valid type returns early from
+  // `normalizeTransitionType`, and any case variant resolves through
+  // `NORMALIZED_TRANSITION_TYPES`. Only the *plural* aliases need an entry.
+  checkerboards: "checkerboard",
+  shapes: "shape",
+  ferris: "ferrisWheel",
+  ferriswheel: "ferrisWheel",
+  flythrough: "flyThrough",
+  flythru: "flyThrough",
+  pagecurl: "pageCurl",
+  pagecurldouble: "pageCurlDouble",
+  pagecurlsingle: "pageCurlSingle",
+  wheelreverse: "wheelReverse",
+  slideleft: "slideLeft",
+  slideright: "slideRight",
+  slideup: "slideUp",
+  slidedown: "slideDown"
+};
+var NORMALIZED_TRANSITION_TYPES = new Map(
+  TRANSITION_TYPES.map((type) => [normalizeToken(type), type])
+);
+function isTransitionType(value) {
+  return TRANSITION_TYPE_SET.has(value);
+}
+function normalizeTransitionType(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (isTransitionType(trimmed)) return trimmed;
+  const normalized = normalizeToken(trimmed);
+  return TRANSITION_TYPE_ALIASES[normalized] ?? NORMALIZED_TRANSITION_TYPES.get(normalized) ?? null;
+}
+function normalizeTransitionDirection(value) {
+  const normalized = normalizeToken(value);
+  switch (normalized) {
+    case "left":
+    case "l":
+      return "left";
+    case "right":
+    case "r":
+      return "right";
+    case "up":
+    case "u":
+      return "up";
+    case "down":
+    case "d":
+      return "down";
+    case "in":
+      return "in";
+    case "out":
+      return "out";
+    case "horizontal":
+    case "horz":
+    case "h":
+      return "horizontal";
+    case "vertical":
+    case "vert":
+    case "v":
+      return "vertical";
+    default:
+      return null;
+  }
+}
+function resolveTransitionDuration(transition, fallback = DEFAULT_TRANSITION_DURATION_SECONDS) {
+  const duration = transition?.duration;
+  return duration != null && Number.isFinite(duration) && duration > 0 ? duration : fallback;
+}
+function resolveBlockTransition(block, theme, blockIndex) {
+  if (block.transition) return block.transition;
+  if (blockIndex === 0) return void 0;
+  return theme.renderStyle.defaultTransition;
+}
+function normalizeToken(value) {
+  return value.toLowerCase().replace(/[\s_-]+/g, "");
+}
+
+export {
+  DEFAULT_TRANSITION_DURATION_SECONDS,
+  TRANSITION_TYPES,
+  TRANSITION_DIRECTIONS,
+  isTransitionType,
+  normalizeTransitionType,
+  normalizeTransitionDirection,
+  resolveTransitionDuration,
+  resolveBlockTransition
+};
+//# sourceMappingURL=chunk-QE7TWGVT.js.map

package/dist/chunk-QE7TWGVT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schemas/Transitions.ts"],"sourcesContent":["/**\n * Shared transition vocabulary for block-to-block slide changes.\n *\n * The canonical names are based on PowerPoint / PresentationML transition\n * names where possible, with a few legacy renderer aliases kept so older\n * Squisq documents continue to work.\n */\n\nexport const DEFAULT_TRANSITION_DURATION_SECONDS = 0.7;\n\nexport const TRANSITION_TYPES = [\n  // Existing / common transitions\n  'cut',\n  'fade',\n  'dissolve',\n  'push',\n  'wipe',\n  'split',\n  'reveal',\n  'randomBars',\n  'shape',\n  'uncover',\n  'cover',\n  'zoom',\n  'pan',\n\n  // PowerPoint subtle / exciting transitions\n  'flash',\n  'fallOver',\n  'drape',\n  'curtains',\n  'wind',\n  'prestige',\n  'fracture',\n  'crush',\n  'peelOff',\n  'pageCurl',\n  'airplane',\n  'origami',\n  'checkerboard',\n  'blinds',\n  'clock',\n  'ripple',\n  'honeycomb',\n  'glitter',\n  'vortex',\n  'shred',\n  'switch',\n  'flip',\n  'gallery',\n  'cube',\n  'doors',\n  'box',\n  'ferrisWheel',\n  'conveyor',\n  'rotate',\n  'window',\n  'orbit',\n  'flyThrough',\n  'morph',\n\n  // PresentationML/Open XML precise names and legacy aliases\n  'checker',\n  'circle',\n  'comb',\n  'diamond',\n  'newsflash',\n  'plus',\n  'pull',\n  'random',\n  'randomBar',\n  'strips',\n  'wedge',\n  'wheel',\n  'prism',\n  'warp',\n  'ferris',\n  'flythrough',\n  'wheelReverse',\n  'pageCurlDouble',\n  'pageCurlSingle',\n  'slideLeft',\n  'slideRight',\n  'slideUp',\n  'slideDown',\n] as const;\n\nexport type TransitionType = (typeof TRANSITION_TYPES)[number];\n\nexport const TRANSITION_DIRECTIONS = [\n  'left',\n  'right',\n  'up',\n  'down',\n  'in',\n  'out',\n  'horizontal',\n  'vertical',\n] as const;\n\nexport type TransitionDirection = (typeof TRANSITION_DIRECTIONS)[number];\n\n/**\n * Transition between blocks.\n *\n * A block's transition is the lead-in from the previous block. The same\n * transition drives the entering block and the previous block's exit.\n */\nexport interface Transition {\n  /** Transition type */\n  type: TransitionType;\n  /** Duration in seconds. Defaults to DEFAULT_TRANSITION_DURATION_SECONDS. */\n  duration?: number;\n  /** Optional direction/variant for directional transitions. */\n  direction?: TransitionDirection;\n}\n\nconst TRANSITION_TYPE_SET = new Set<string>(TRANSITION_TYPES);\n\nconst TRANSITION_TYPE_ALIASES: Record<string, TransitionType> = {\n  none: 'cut',\n  randombars: 'randomBars',\n  randombar: 'randomBar',\n  // Self-referential spellings (`checkerboard`, `shape`, `uncover`) are\n  // intentionally absent: an exact valid type returns early from\n  // `normalizeTransitionType`, and any case variant resolves through\n  // `NORMALIZED_TRANSITION_TYPES`. Only the *plural* aliases need an entry.\n  checkerboards: 'checkerboard',\n  shapes: 'shape',\n  ferris: 'ferrisWheel',\n  ferriswheel: 'ferrisWheel',\n  flythrough: 'flyThrough',\n  flythru: 'flyThrough',\n  pagecurl: 'pageCurl',\n  pagecurldouble: 'pageCurlDouble',\n  pagecurlsingle: 'pageCurlSingle',\n  wheelreverse: 'wheelReverse',\n  slideleft: 'slideLeft',\n  slideright: 'slideRight',\n  slideup: 'slideUp',\n  slidedown: 'slideDown',\n};\n\nconst NORMALIZED_TRANSITION_TYPES = new Map<string, TransitionType>(\n  TRANSITION_TYPES.map((type) => [normalizeToken(type), type]),\n);\n\nexport function isTransitionType(value: string): value is TransitionType {\n  return TRANSITION_TYPE_SET.has(value);\n}\n\nexport function normalizeTransitionType(value: string): TransitionType | null {\n  const trimmed = value.trim();\n  if (!trimmed) return null;\n  if (isTransitionType(trimmed)) return trimmed;\n  const normalized = normalizeToken(trimmed);\n  return TRANSITION_TYPE_ALIASES[normalized] ?? NORMALIZED_TRANSITION_TYPES.get(normalized) ?? null;\n}\n\nexport function normalizeTransitionDirection(value: string): TransitionDirection | null {\n  const normalized = normalizeToken(value);\n  switch (normalized) {\n    case 'left':\n    case 'l':\n      return 'left';\n    case 'right':\n    case 'r':\n      return 'right';\n    case 'up':\n    case 'u':\n      return 'up';\n    case 'down':\n    case 'd':\n      return 'down';\n    case 'in':\n      return 'in';\n    case 'out':\n      return 'out';\n    case 'horizontal':\n    case 'horz':\n    case 'h':\n      return 'horizontal';\n    case 'vertical':\n    case 'vert':\n    case 'v':\n      return 'vertical';\n    default:\n      return null;\n  }\n}\n\nexport function resolveTransitionDuration(\n  transition: Transition | undefined,\n  fallback: number = DEFAULT_TRANSITION_DURATION_SECONDS,\n): number {\n  const duration = transition?.duration;\n  return duration != null && Number.isFinite(duration) && duration > 0 ? duration : fallback;\n}\n\n/**\n * Resolve the effective transition for a block: the authored value wins\n * (markdown frontmatter and transform styles both write `block.transition`\n * upstream), then the theme's `renderStyle.defaultTransition`, then\n * `undefined` (the player's built-in default).\n *\n * Block 0 never gets a theme default — an entrance transition on the first\n * block would dim the opening frames of every exported video.\n *\n * The theme parameter is structural (not `Theme`) to avoid a schema import\n * cycle; pass any resolved theme.\n */\nexport function resolveBlockTransition(\n  block: { transition?: Transition },\n  theme: { renderStyle: { defaultTransition?: Transition } },\n  blockIndex: number,\n): Transition | undefined {\n  if (block.transition) return block.transition;\n  if (blockIndex === 0) return undefined;\n  return theme.renderStyle.defaultTransition;\n}\n\nfunction normalizeToken(value: string): string {\n  return value.toLowerCase().replace(/[\\s_-]+/g, '');\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-RUDYOTA6.js

@@ -0,0 +1,345 @@
+// src/doc/utils/shapeGeometry.ts
+var PATH_SHAPE_KINDS = /* @__PURE__ */ new Set([
+  "triangle",
+  "right-triangle",
+  "diamond",
+  "pentagon",
+  "hexagon",
+  "octagon",
+  "star",
+  "star4",
+  "star6",
+  "parallelogram",
+  "trapezoid",
+  "plus",
+  "chevron",
+  "arrow-right",
+  "arrow-left",
+  "arrow-up",
+  "arrow-down",
+  "double-arrow",
+  "callout",
+  "cylinder",
+  "cloud",
+  "heart",
+  "lightning"
+]);
+function r(n) {
+  return Math.round(n * 10) / 10;
+}
+function poly(points) {
+  if (points.length === 0) return "";
+  const [first, ...rest] = points;
+  const head = `M ${r(first[0])} ${r(first[1])}`;
+  const tail = rest.map(([x, y]) => `L ${r(x)} ${r(y)}`).join(" ");
+  return `${head} ${tail} Z`;
+}
+function regular(cx, cy, rx, ry, sides, rotation) {
+  const pts = [];
+  for (let i = 0; i < sides; i++) {
+    const a = rotation + i * 2 * Math.PI / sides;
+    pts.push([cx + rx * Math.cos(a), cy + ry * Math.sin(a)]);
+  }
+  return pts;
+}
+function star(cx, cy, rx, ry, spikes, innerRatio) {
+  const pts = [];
+  const rot = -Math.PI / 2;
+  for (let i = 0; i < spikes * 2; i++) {
+    const outer = i % 2 === 0;
+    const a = rot + i * Math.PI / spikes;
+    const fx = outer ? rx : rx * innerRatio;
+    const fy = outer ? ry : ry * innerRatio;
+    pts.push([cx + fx * Math.cos(a), cy + fy * Math.sin(a)]);
+  }
+  return pts;
+}
+function shapePath(kind, x, y, w, h) {
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  const rx = w / 2;
+  const ry = h / 2;
+  const right = x + w;
+  const bottom = y + h;
+  switch (kind) {
+    case "triangle":
+      return poly([
+        [cx, y],
+        [right, bottom],
+        [x, bottom]
+      ]);
+    case "right-triangle":
+      return poly([
+        [x, y],
+        [x, bottom],
+        [right, bottom]
+      ]);
+    case "diamond":
+      return poly([
+        [cx, y],
+        [right, cy],
+        [cx, bottom],
+        [x, cy]
+      ]);
+    case "pentagon":
+      return poly(regular(cx, cy, rx, ry, 5, -Math.PI / 2));
+    case "hexagon": {
+      const inset = w * 0.25;
+      return poly([
+        [x + inset, y],
+        [right - inset, y],
+        [right, cy],
+        [right - inset, bottom],
+        [x + inset, bottom],
+        [x, cy]
+      ]);
+    }
+    case "octagon": {
+      const cut = Math.min(w, h) * 0.29;
+      return poly([
+        [x + cut, y],
+        [right - cut, y],
+        [right, y + cut],
+        [right, bottom - cut],
+        [right - cut, bottom],
+        [x + cut, bottom],
+        [x, bottom - cut],
+        [x, y + cut]
+      ]);
+    }
+    case "star":
+      return poly(star(cx, cy, rx, ry, 5, 0.4));
+    case "star4":
+      return poly(star(cx, cy, rx, ry, 4, 0.4));
+    case "star6":
+      return poly(star(cx, cy, rx, ry, 6, 0.5));
+    case "parallelogram": {
+      const off = w * 0.25;
+      return poly([
+        [x + off, y],
+        [right, y],
+        [right - off, bottom],
+        [x, bottom]
+      ]);
+    }
+    case "trapezoid": {
+      const off = w * 0.25;
+      return poly([
+        [x + off, y],
+        [right - off, y],
+        [right, bottom],
+        [x, bottom]
+      ]);
+    }
+    case "plus": {
+      const t = Math.min(w, h) / 3;
+      const lx = x + (w - t) / 2;
+      const rxp = lx + t;
+      const ty = y + (h - t) / 2;
+      const byp = ty + t;
+      return poly([
+        [lx, y],
+        [rxp, y],
+        [rxp, ty],
+        [right, ty],
+        [right, byp],
+        [rxp, byp],
+        [rxp, bottom],
+        [lx, bottom],
+        [lx, byp],
+        [x, byp],
+        [x, ty],
+        [lx, ty]
+      ]);
+    }
+    case "chevron": {
+      const notch = w * 0.25;
+      return poly([
+        [x, y],
+        [right - notch, y],
+        [right, cy],
+        [right - notch, bottom],
+        [x, bottom],
+        [x + notch, cy]
+      ]);
+    }
+    case "arrow-right":
+      return blockArrow(x, y, w, h, "right");
+    case "arrow-left":
+      return blockArrow(x, y, w, h, "left");
+    case "arrow-up":
+      return blockArrow(x, y, w, h, "up");
+    case "arrow-down":
+      return blockArrow(x, y, w, h, "down");
+    case "double-arrow": {
+      const head = w * 0.3;
+      const bodyT = h * 0.4;
+      const ty = cy - bodyT / 2;
+      const by = cy + bodyT / 2;
+      return poly([
+        [x, cy],
+        [x + head, y],
+        [x + head, ty],
+        [right - head, ty],
+        [right - head, y],
+        [right, cy],
+        [right - head, bottom],
+        [right - head, by],
+        [x + head, by],
+        [x + head, bottom]
+      ]);
+    }
+    case "callout": {
+      const bodyH = h * 0.78;
+      const bb = y + bodyH;
+      const tailX = x + w * 0.25;
+      return `M ${r(x)} ${r(y)} L ${r(right)} ${r(y)} L ${r(right)} ${r(bb)} L ${r(tailX + w * 0.12)} ${r(bb)} L ${r(tailX)} ${r(bottom)} L ${r(tailX - w * 0.02)} ${r(bb)} L ${r(x)} ${r(bb)} Z`;
+    }
+    case "cylinder": {
+      const ell = h * 0.16;
+      return `M ${r(x)} ${r(y + ell)} A ${r(rx)} ${r(ell)} 0 0 1 ${r(right)} ${r(y + ell)} L ${r(right)} ${r(bottom - ell)} A ${r(rx)} ${r(ell)} 0 0 1 ${r(x)} ${r(bottom - ell)} Z M ${r(x)} ${r(y + ell)} A ${r(rx)} ${r(ell)} 0 0 0 ${r(right)} ${r(y + ell)}`;
+    }
+    case "cloud": {
+      const b = h * 0.5;
+      return `M ${r(x + w * 0.2)} ${r(bottom)} A ${r(w * 0.2)} ${r(b)} 0 0 1 ${r(x + w * 0.15)} ${r(cy)} A ${r(w * 0.2)} ${r(b)} 0 0 1 ${r(x + w * 0.45)} ${r(y + h * 0.2)} A ${r(w * 0.2)} ${r(b)} 0 0 1 ${r(x + w * 0.8)} ${r(y + h * 0.25)} A ${r(w * 0.18)} ${r(b)} 0 0 1 ${r(x + w * 0.85)} ${r(bottom)} Z`;
+    }
+    case "heart": {
+      const topY = y + h * 0.3;
+      return `M ${r(cx)} ${r(bottom)} C ${r(x - w * 0.1)} ${r(cy)} ${r(x)} ${r(y)} ${r(cx)} ${r(topY)} C ${r(right)} ${r(y)} ${r(right + w * 0.1)} ${r(cy)} ${r(cx)} ${r(bottom)} Z`;
+    }
+    case "lightning":
+      return poly([
+        [x + w * 0.55, y],
+        [x + w * 0.2, y + h * 0.55],
+        [x + w * 0.45, y + h * 0.55],
+        [x + w * 0.3, bottom],
+        [right, y + h * 0.4],
+        [x + w * 0.55, y + h * 0.4]
+      ]);
+    default:
+      return null;
+  }
+}
+function blockArrow(x, y, w, h, dir) {
+  const right = x + w;
+  const bottom = y + h;
+  const cx = x + w / 2;
+  const cy = y + h / 2;
+  if (dir === "right" || dir === "left") {
+    const head2 = w * 0.4;
+    const bodyT2 = h * 0.5;
+    const ty = cy - bodyT2 / 2;
+    const by = cy + bodyT2 / 2;
+    if (dir === "right") {
+      return poly([
+        [x, ty],
+        [right - head2, ty],
+        [right - head2, y],
+        [right, cy],
+        [right - head2, bottom],
+        [right - head2, by],
+        [x, by]
+      ]);
+    }
+    return poly([
+      [right, ty],
+      [x + head2, ty],
+      [x + head2, y],
+      [x, cy],
+      [x + head2, bottom],
+      [x + head2, by],
+      [right, by]
+    ]);
+  }
+  const head = h * 0.4;
+  const bodyT = w * 0.5;
+  const lx = cx - bodyT / 2;
+  const rxp = cx + bodyT / 2;
+  if (dir === "down") {
+    return poly([
+      [lx, y],
+      [rxp, y],
+      [rxp, bottom - head],
+      [right, bottom - head],
+      [cx, bottom],
+      [x, bottom - head],
+      [lx, bottom - head]
+    ]);
+  }
+  return poly([
+    [lx, bottom],
+    [rxp, bottom],
+    [rxp, y + head],
+    [right, y + head],
+    [cx, y],
+    [x, y + head],
+    [lx, y + head]
+  ]);
+}
+function markerPath(style, dir) {
+  const mirror = dir === "start";
+  const mx = (n) => mirror ? 10 - n : n;
+  const tri = (closed) => `M ${mx(0)} 0 L ${mx(10)} 5 L ${mx(0)} 10${closed ? " z" : ""}`;
+  switch (style) {
+    case "arrow":
+      return { d: tri(true), filled: true };
+    case "open":
+      return { d: tri(false), filled: false };
+    case "diamond":
+      return { d: "M 0 5 L 5 0 L 10 5 L 5 10 z", filled: true };
+    case "square":
+      return { d: "M 1 1 L 9 1 L 9 9 L 1 9 z", filled: true };
+    case "circle":
+      return { d: "M 0 5 A 5 5 0 1 0 10 5 A 5 5 0 1 0 0 5 z", filled: true };
+    case "none":
+    default:
+      return null;
+  }
+}
+function clipPoint(from, to) {
+  const dx = to.cx - from.cx;
+  const dy = to.cy - from.cy;
+  if (dx === 0 && dy === 0) return { x: from.cx, y: from.cy };
+  const sx = Math.abs(dx) > 0 ? from.rx / Math.abs(dx) : Infinity;
+  const sy = Math.abs(dy) > 0 ? from.ry / Math.abs(dy) : Infinity;
+  const s = Math.min(sx, sy);
+  return { x: from.cx + dx * s, y: from.cy + dy * s };
+}
+function clipEndpoints(a, b) {
+  return { start: clipPoint(a, b), end: clipPoint(b, a) };
+}
+function connectorPath(routing, start, end) {
+  if (routing === "straight") {
+    return `M ${r(start.x)} ${r(start.y)} L ${r(end.x)} ${r(end.y)}`;
+  }
+  if (routing === "orthogonal") {
+    const midX = (start.x + end.x) / 2;
+    return `M ${r(start.x)} ${r(start.y)} L ${r(midX)} ${r(start.y)} L ${r(midX)} ${r(end.y)} L ${r(end.x)} ${r(end.y)}`;
+  }
+  const dx = Math.abs(end.x - start.x);
+  const cp = Math.max(40, dx / 2);
+  return `M ${r(start.x)} ${r(start.y)} C ${r(start.x + cp)} ${r(start.y)}, ${r(end.x - cp)} ${r(end.y)}, ${r(end.x)} ${r(end.y)}`;
+}
+function lineStyleDasharray(style) {
+  switch (style?.toLowerCase()) {
+    case "dashed":
+    case "dash":
+      return "8 6";
+    case "dotted":
+    case "dot":
+      return "2 6";
+    default:
+      return void 0;
+  }
+}
+
+export {
+  PATH_SHAPE_KINDS,
+  shapePath,
+  markerPath,
+  clipPoint,
+  clipEndpoints,
+  connectorPath,
+  lineStyleDasharray
+};
+//# sourceMappingURL=chunk-RUDYOTA6.js.map