import { C as CompositionVariable } from './types-ewozML_N.js';
export { A as AddElementData, b as Asset, B as BooleanVariable, c as CANVAS_DIMENSIONS, d as COMPOSITION_VARIABLE_TYPES, a as CanvasResolution, e as ColorVariable, f as CompositionAPI, g as CompositionAsset, h as CompositionSpec, i as CompositionVariableBase, j as CompositionVariableType, D as DEFAULT_DURATIONS, E as ElementKeyframes, k as EnumVariable, F as FontVariable, I as ImageVariable, K as Keyframe, l as KeyframeProperties, M as MediaElementType, m as MediaFile, N as NumberVariable, P as PlayerAPI, R as ResolvedResolutionFlag, n as StageZoom, S as StageZoomKeyframe, o as StringVariable, p as TIMELINE_COLORS, q as TimelineCompositionElement, T as TimelineElement, r as TimelineElementBase, s as TimelineElementType, t as TimelineMediaElement, u as TimelineTextElement, v as VALID_CANVAS_RESOLUTIONS, V as ValidationResult, W as WaveformData, w as getDefaultStageZoom, x as isAspectAgnosticResolutionAlias, y as isCompositionElement, z as isMediaElement, G as isTextElement, H as normalizeResolutionFlag, J as resolveResolutionFlagPair } from './types-ewozML_N.js';
export { CANONICAL_AUTHORED_TIMING_ATTRIBUTES, COMPOSITION_ATTRIBUTES, COMPOSITION_CONTRACT_VERSION, ClipAttributeReader, ClipAttributeWriter, ClipTiming, ClipTimingDiagnostic, ClipTimingDiagnosticCode, ClipTimingUpdate, ClipTimingWriteError, DERIVED_TIMING_ATTRIBUTES, LEGACY_TIMING_ATTRIBUTES, ReadClipTimingOptions, ReferenceExpression, parseNumeric, parseStartExpression, readClipTiming, writeClipTiming } from './compositionContract.js';

/**
 * Browser-safe parser for the `data-composition-variables` schema attribute.
 * Lives outside htmlParser.ts so browser consumers (SDK, Studio, lint) can
 * import it via `@hyperframes/parsers/composition` without pulling the
 * linkedom/Node HTML-parser machinery from the main entry.
 */

/**
 * Scalar variable values (string/number/boolean) are the ones that flow into
 * CSS custom props and text bindings; font/image values are object-shaped.
 * Shared so the SDK's CSS-compat writes, the runtime bindings, and Studio's
 * display logic can never disagree on what "scalar" means.
 */
declare function isScalarVariableValue(value: unknown): value is string | number | boolean;
/**
 * True when the value is a structurally valid variable declaration: id, label,
 * a known type, a default matching that type, and options[] for enums. The
 * same predicate parseCompositionVariables filters with — exported so writers
 * (SDK declaration ops, Studio forms) can validate before persisting.
 */
declare function isCompositionVariable(v: unknown): v is CompositionVariable;
/**
 * Parse the typed variable declarations from an element's
 * `data-composition-variables` attribute. Malformed entries (wrong shape,
 * unknown type, default not matching the declared type) are dropped; an
 * absent attribute, invalid JSON, or a non-array payload yields `[]`.
 */
declare function parseCompositionVariables(htmlEl: Element): CompositionVariable[];
/**
 * Protocol allowlist for a resolved media URL. Relative URLs (no scheme) resolve
 * against the page origin and are always safe. Absolute URLs are restricted to
 * http(s)/blob and image data: URIs -- defense-in-depth alongside the runtime's
 * VAR_SRC_TAGS element guard, blocking `javascript:`, `data:text/html`, `file:`,
 * etc. even if a future tag slips past it. Control chars are stripped before the
 * scheme test because browsers ignore them when parsing the URL.
 *
 * Lives here rather than in the runtime because the linter has to reach the same
 * verdict on a declared default statically: a value this rejects is dropped at
 * bind time and the element's authored fallback renders instead, so a second copy
 * of the scheme list would let lint and the runtime disagree silently.
 */
declare function isSafeMediaUrl(url: string): boolean;

declare function decodeUrlPathVariants(path: string): string[];

/**
 * Browser-safe static scan for composition-variable reads in script text.
 *
 * Compositions read variables by calling the runtime API — `getVariables()`
 * bare (sub-comp scoped shadow) or via `__hyperframes.getVariables()` /
 * `window.__hyperframes.getVariables()` — and there is no DOM-attribute
 * binding to scan, so "which variables does this composition use" can only be
 * derived from the scripts. This is a best-effort static analysis: the
 * patterns agents actually write (destructuring, member access, a single
 * alias variable) resolve to ids; anything opaque flips `scanIncomplete`
 * so consumers can present usage as a lower bound instead of a fact.
 *
 * AST nodes are handled untyped (same convention as gsapParserAcorn.ts) —
 * acorn's structural types don't survive acorn-walk's visitor signatures.
 */
interface VariableUsageScan {
    /** Variable ids statically read by the script, in first-seen order. */
    usedIds: string[];
    /**
     * True when the script accesses variables in a way the scan cannot resolve
     * (computed keys, rest spreads, the values object escaping into a call…) or
     * when the script fails to parse — usedIds is then a lower bound.
     */
    scanIncomplete: boolean;
}
declare function scanVariableUsage(scriptText: string): VariableUsageScan;

/**
 * Single source of truth for the deterministic font alias map. Both the
 * producer's @font-face injector and the core lint rules import from here,
 * eliminating manual drift between the two.
 *
 * Keys are lowercase font family names. Values are canonical font slugs
 * matching CANONICAL_FONTS keys in the producer's deterministicFonts module.
 */
declare const FONT_ALIAS_MAP: {
    inter: string;
    montserrat: string;
    outfit: string;
    nunito: string;
    oswald: string;
    "league gothic": string;
    "archivo black": string;
    "space mono": string;
    "ibm plex mono": string;
    "jetbrains mono": string;
    "eb garamond": string;
    "playfair display": string;
    "source code pro": string;
    "noto sans jp": string;
    roboto: string;
    "open sans": string;
    lato: string;
    poppins: string;
    "helvetica neue": string;
    helvetica: string;
    arial: string;
    "helvetica bold": string;
    futura: string;
    "din alternate": string;
    "arial black": string;
    "bebas neue": string;
    "courier new": string;
    courier: string;
    garamond: string;
    "noto sans japanese": string;
    "segoe ui": string;
    "sf pro": string;
    "sf pro display": string;
    "sf pro text": string;
    "sf pro rounded": string;
    avenir: string;
    "avenir next": string;
    "lucida grande": string;
    geneva: string;
    optima: string;
    verdana: string;
    tahoma: string;
    "trebuchet ms": string;
    calibri: string;
    candara: string;
    corbel: string;
    "lucida sans": string;
    "lucida sans unicode": string;
    "noto sans": string;
    "dejavu sans": string;
    "liberation sans": string;
    "sf mono": string;
    menlo: string;
    monaco: string;
    consolas: string;
    "lucida console": string;
    "lucida sans typewriter": string;
    "andale mono": string;
    "dejavu sans mono": string;
    "liberation mono": string;
    georgia: string;
    palatino: string;
    "palatino linotype": string;
    "book antiqua": string;
    cambria: string;
    times: string;
    "times new roman": string;
    "dejavu serif": string;
    "liberation serif": string;
};
declare const FONT_ALIAS_KEYS: ReadonlySet<string>;
/**
 * Human-readable display names for canonical font slugs. Used by the lint
 * rule to tell authors what their aliased font will render as.
 */
declare const CANONICAL_FONT_DISPLAY_NAMES: Readonly<Record<string, string>>;
/**
 * Resolve a font alias to its canonical display name, or undefined if the
 * alias is not in the map.
 */
declare function resolveAliasDisplayName(alias: string): string | undefined;

export { CANONICAL_FONT_DISPLAY_NAMES, CompositionVariable, FONT_ALIAS_KEYS, FONT_ALIAS_MAP, type VariableUsageScan, decodeUrlPathVariants, isCompositionVariable, isSafeMediaUrl, isScalarVariableValue, parseCompositionVariables, resolveAliasDisplayName, scanVariableUsage };