@hyperfixi/core 3.3.0 → 4.0.1

package/dist/commands/helpers/event-waiting.d.ts

@@ -1,37 +0,0 @@
-export interface EventWaitResult<T = Event> {
-    event: T | null;
-    timedOut: boolean;
-    cancelled: boolean;
-}
-export interface TransitionWaitResult {
-    completed: boolean;
-    cancelled: boolean;
-}
-export interface AnimationWaitResult {
-    completed: boolean;
-    type: 'transition' | 'animation' | 'timeout';
-}
-export declare function waitForEvent<T extends Event = Event>(target: EventTarget, eventName: string, timeout?: number, signal?: AbortSignal): Promise<EventWaitResult<T>>;
-export declare function waitForTime(ms: number): Promise<void>;
-export declare function waitForTransitionEnd(element: HTMLElement, property: string, duration: number): Promise<TransitionWaitResult>;
-export declare function waitForAnimationComplete(element: HTMLElement, computedAnimationTime: number, userTimeout: number): Promise<AnimationWaitResult>;
-export type WaitCondition = {
-    type: 'time';
-    ms: number;
-} | {
-    type: 'event';
-    target: EventTarget;
-    eventName: string;
-};
-export interface RaceResult {
-    winner: WaitCondition;
-    result: number | Event;
-}
-export declare function waitForFirst(conditions: WaitCondition[]): Promise<RaceResult>;
-export declare function createGuardedFinisher<T>(cleanup: () => void, resolve: (value: T) => void): (result: T) => void;
-export declare function createOnceGuard<T extends (...args: any[]) => void>(callback: T): (...args: Parameters<T>) => void;
-export declare function createCleanupManager(): {
-    add: (fn: () => void) => void;
-    cleanup: () => void;
-};
-//# sourceMappingURL=event-waiting.d.ts.map

package/dist/commands/helpers/index.d.ts

@@ -1,32 +0,0 @@
-export { convertToNumber, getVariableValue, setVariableValue, resolveElementRef, getElementPropertyValue, setElementPropertyValue, getCurrentNumericValue, setTargetValue, } from './variable-access';
-export { getElementProperty, setElementProperty, getElementValue, setElementValue, isEmpty, isPlainObject, } from './element-property-access';
-export { isPropertyOfExpressionNode, isPropertyAccessNode, isPropertyTargetString, resolvePropertyTargetFromNode, resolvePropertyTargetFromAccessNode, resolvePropertyTargetFromString, resolveAnyPropertyTarget, readPropertyTarget, writePropertyTarget, togglePropertyTarget, } from './property-target';
-export type { PropertyTarget, PropertyOfExpressionNode, PropertyAccessNode, } from './property-target';
-export { resolveElement, resolveElements, resolveTargetsFromArgs, asHTMLElement, isContextRef, isCSSSelector, findClosest, findAll, resolvePossessive, } from './element-resolution';
-export type { ResolveTargetsOptions } from './element-resolution';
-export { parseDuration, parseDurationStrict, parseCSSDurations, calculateMaxAnimationTime, camelToKebab, kebabToCamel, formatDuration, } from './duration-parsing';
-export { parseClasses, isValidClassName, normalizeClassName } from './class-manipulation';
-export { isAttributeSyntax, parseAttribute, parseAttributeName, parseAttributeWithValue, } from './attribute-manipulation';
-export { createCustomEvent, parseEventValue, dispatchCustomEvent } from './event-helpers';
-export type { EventOptions } from './event-helpers';
-export { evaluateCondition, isTruthy } from './condition-helpers';
-export { validateUrl, isExternalUrl, isSafeUrl, normalizeUrl, extractSearchParams, buildUrlWithParams, } from './url-validation';
-export { parseCSSProperty, isCSSPropertySyntax, parseToggleableCSSProperty, getComputedStyleValue, setStyleValue, removeStyleProperty, toggleCSSProperty, isDisplayNone, isVisibilityHidden, isOpacityZero, } from './style-manipulation';
-export type { ToggleableCSSProperty, ParsedCSSProperty } from './style-manipulation';
-export { detectSelectorType, isSmartElementTag, isSmartElementSelector, extractSelectorValue, isClassSelectorNode, isIdSelectorNode, isBareSmartElementNode, SMART_ELEMENT_TAGS, evaluateFirstArg, detectInputType, } from './selector-type-detection';
-export type { SelectorType, SmartElementTag, CommandInputType, ParsedFirstArg, } from './selector-type-detection';
-export { validateTargetArray, isValidTargetArray, validateStringArray, isValidStringArray, validateTypeDiscriminator, isValidType, validateDefined, isDefined, validateNonEmptyString, isNonEmptyString, combineValidations, createValidator, } from './input-validator';
-export type { ValidationResult as InputValidationResult } from './input-validator';
-export { detectSmartElementType, resolveSmartElementTargets, toggleDialog, toggleDetails, toggleSelect, toggleSmartElement, isSmartElement, isDialogElement, isDetailsElement, isSelectElement, isSummaryElement, } from './smart-element';
-export type { SmartElementType, DialogMode } from './smart-element';
-export { toInsertPosition, looksLikeHTML, insertContent, insertContentSemantic, insertElementsInOrder, removeElement, removeElements, swapElements, cloneElement, createElementFromHTML, setInnerHTML, setTextContent, clearElement, } from './dom-mutation';
-export type { ContentInsertPosition, SemanticPosition } from './dom-mutation';
-export { batchApply, batchApplyItems, batchAddClasses, batchRemoveClasses, batchToggleClasses, batchSetAttribute, batchRemoveAttribute, batchToggleAttribute, toggleAttribute, batchSetStyles, batchRemoveStyles, } from './batch-dom-operations';
-export { waitForEvent, waitForTime, waitForTransitionEnd, waitForAnimationComplete, waitForFirst, createGuardedFinisher, createOnceGuard, createCleanupManager, } from './event-waiting';
-export type { EventWaitResult, TransitionWaitResult, AnimationWaitResult, WaitCondition, RaceResult, } from './event-waiting';
-export { createReversionFn, setupDurationReversion, setupEventReversion, setupTemporalModifiers, setupTemporalModifiersForElements, } from './temporal-modifiers';
-export type { ToggleType, CleanupFn, TemporalModifierOptions } from './temporal-modifiers';
-export { executeLoop, createForLoopConfig, createTimesLoopConfig, createWhileLoopConfig, createUntilLoopConfig, createUntilEventLoopConfig, createForeverLoopConfig, } from './loop-executor';
-export type { LoopConfig, LoopIterationContext, LoopResult } from './loop-executor';
-export { missingArgument, invalidTarget, noTargetElements, invalidClassName, invalidAttributeName, invalidSelector, invalidUrl, invalidContext, operationFailed, parseError, executionError, unsupportedFeature, toError, throwValidation, } from './error-helpers';
-//# sourceMappingURL=index.d.ts.map

package/dist/commands/helpers/input-validator.d.ts

@@ -1,23 +0,0 @@
-export interface ValidationResult {
-    valid: boolean;
-    error?: string;
-}
-export declare function validateTargetArray(targets: unknown[], commandName?: string): ValidationResult;
-export declare function isValidTargetArray(targets: unknown[]): targets is HTMLElement[];
-export declare function validateStringArray(arr: unknown[], fieldName?: string, minLength?: number): ValidationResult;
-export declare function isValidStringArray(arr: unknown[], minLength?: number): arr is string[];
-export declare function validateTypeDiscriminator<T extends string>(type: unknown, allowed: readonly T[], commandName?: string): ValidationResult;
-export declare function isValidType<T extends string>(type: unknown, allowed: readonly T[]): type is T;
-export declare function validateDefined(value: unknown, fieldName: string): ValidationResult;
-export declare function isDefined<T>(value: T | null | undefined): value is T;
-export declare function validateNonEmptyString(value: unknown, fieldName: string): ValidationResult;
-export declare function isNonEmptyString(value: unknown): value is string;
-export declare function combineValidations(...results: ValidationResult[]): ValidationResult;
-export declare function createValidator(commandName: string): {
-    targets: (targets: unknown[]) => ValidationResult;
-    strings: (arr: unknown[], fieldName: string, minLength?: number) => ValidationResult;
-    type: <T extends string>(type: unknown, allowed: readonly T[]) => ValidationResult;
-    defined: (value: unknown, fieldName: string) => ValidationResult;
-    nonEmptyString: (value: unknown, fieldName: string) => ValidationResult;
-};
-//# sourceMappingURL=input-validator.d.ts.map

package/dist/commands/helpers/loop-executor.d.ts

@@ -1,56 +0,0 @@
-import type { TypedExecutionContext } from '../../types/core';
-import type { ExecutionSignal } from '../../types/result';
-import type { Op } from '../../types/program';
-export interface LoopConfig {
-    type: 'for' | 'times' | 'while' | 'until' | 'until-event' | 'forever';
-    maxIterations?: number;
-    shouldContinue: (ctx: LoopIterationContext) => boolean | Promise<boolean>;
-    beforeIteration?: (ctx: LoopIterationContext, context: TypedExecutionContext) => void | Promise<void>;
-    eventSetup?: {
-        eventName: string;
-        target: EventTarget;
-        onEvent: () => void;
-    };
-}
-export interface LoopIterationContext {
-    index: number;
-    item?: unknown;
-    collection?: unknown[];
-    count?: number;
-    conditionExpr?: unknown;
-    indexVariable?: string;
-    itemVariable?: string;
-    eventFired?: boolean;
-}
-export interface LoopResult {
-    iterations: number;
-    lastResult: unknown;
-    interrupted: boolean;
-    signal?: ExecutionSignal;
-}
-export declare function executeLoop(config: LoopConfig, context: TypedExecutionContext, iterCtx: LoopIterationContext, body: Op): Promise<LoopResult>;
-export declare function createForLoopConfig(collection: unknown[], itemVariable: string, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createTimesLoopConfig(count: number, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createWhileLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean | Promise<boolean>, context: TypedExecutionContext, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createUntilLoopConfig(conditionExpr: unknown, evaluateCondition: (expr: unknown, ctx: TypedExecutionContext) => boolean | Promise<boolean>, context: TypedExecutionContext, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createUntilEventLoopConfig(eventName: string, eventTarget: EventTarget, indexVariable?: string): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-export declare function createForeverLoopConfig(indexVariable?: string, maxIterations?: number): {
-    config: LoopConfig;
-    iterCtx: LoopIterationContext;
-};
-//# sourceMappingURL=loop-executor.d.ts.map

package/dist/commands/helpers/numeric-target-parser.d.ts

@@ -1,21 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type NodeWriterFn } from '../../parser/extensions';
-export interface NumericTargetRawInput {
-    args: ASTNode[];
-    modifiers: Record<string, ASTNode>;
-}
-export interface NumericCustomWrite {
-    node: ASTNode;
-    writer: NodeWriterFn;
-    currentValue: number;
-}
-export interface NumericTargetInput {
-    target: string | HTMLElement | number | Record<string, unknown>;
-    property?: string;
-    scope?: 'global' | 'local';
-    amount: number;
-    customWrite?: NumericCustomWrite;
-}
-export declare function parseNumericTargetInput(raw: NumericTargetRawInput, evaluator: ExpressionEvaluator, context: ExecutionContext, commandName: string): Promise<NumericTargetInput>;
-//# sourceMappingURL=numeric-target-parser.d.ts.map

package/dist/commands/helpers/property-target.d.ts

@@ -1,20 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../../types/base-types';
-import type { PropertyOfExpressionNode, PropertyAccessNode } from '../../ast/nodes';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export interface PropertyTarget {
-    element: HTMLElement;
-    property: string;
-}
-export type { PropertyOfExpressionNode, PropertyAccessNode };
-import { isPropertyOfExpressionNode as isPropertyOfExpressionNodeGuard, isPropertyAccessNode as isPropertyAccessNodeGuard } from '../../ast/guards';
-export declare const isPropertyOfExpressionNode: typeof isPropertyOfExpressionNodeGuard;
-export declare const isPropertyAccessNode: typeof isPropertyAccessNodeGuard;
-export declare function isPropertyTargetString(value: unknown): value is string;
-export declare function resolvePropertyTargetFromNode(node: PropertyOfExpressionNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PropertyTarget | null>;
-export declare function resolvePropertyTargetFromAccessNode(node: PropertyAccessNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PropertyTarget | null>;
-export declare function resolvePropertyTargetFromString(value: string, context: ExecutionContext): PropertyTarget | null;
-export declare function resolveAnyPropertyTarget(node: ASTNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<PropertyTarget | null>;
-export declare function readPropertyTarget(target: PropertyTarget): unknown;
-export declare function writePropertyTarget(target: PropertyTarget, value: unknown): void;
-export declare function togglePropertyTarget(target: PropertyTarget): unknown;
-//# sourceMappingURL=property-target.d.ts.map

package/dist/commands/helpers/selector-type-detection.d.ts

@@ -1,24 +0,0 @@
-import type { ASTNode, ExecutionContext } from '../../types/base-types';
-export type SelectorType = 'class' | 'attribute' | 'css-property' | 'element' | 'identifier' | 'unknown';
-export type SmartElementTag = 'dialog' | 'details' | 'summary' | 'select';
-export declare const SMART_ELEMENT_TAGS: readonly SmartElementTag[];
-export declare function detectSelectorType(value: string): SelectorType;
-export declare function isSmartElementTag(tag: string): tag is SmartElementTag;
-export declare function isSmartElementSelector(selector: string): boolean;
-export declare function extractSelectorValue(node: ASTNode): string | null;
-export declare function isClassSelectorNode(node: ASTNode): boolean;
-export declare function isIdSelectorNode(node: ASTNode): boolean;
-export declare function isCSSPropertySelectorNode(node: ASTNode): boolean;
-export declare function isAttributeSelectorNode(node: ASTNode): boolean;
-export declare function extractAttributeValue(node: ASTNode): string | null;
-export declare function isBareSmartElementNode(node: ASTNode): boolean;
-export type CommandInputType = 'classes' | 'attribute' | 'css-property' | 'element' | 'styles' | 'unknown';
-export interface ParsedFirstArg {
-    value: unknown;
-    extractedFromNode: boolean;
-}
-export declare function evaluateFirstArg(firstArg: ASTNode, evaluator: {
-    evaluate: (node: ASTNode, context: ExecutionContext) => Promise<unknown>;
-}, context: ExecutionContext): Promise<ParsedFirstArg>;
-export declare function detectInputType(value: string): CommandInputType;
-//# sourceMappingURL=selector-type-detection.d.ts.map

package/dist/commands/helpers/slots.d.ts

@@ -1,5 +0,0 @@
-import type { ExecutionContext, ExpressionNode } from '../../types/core';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export declare function requireSlot(node: ExpressionNode | undefined, what: string): ExpressionNode;
-export declare function evaluateSlot(evaluator: ExpressionEvaluator, context: ExecutionContext, node: ExpressionNode | undefined, what: string): Promise<unknown>;
-//# sourceMappingURL=slots.d.ts.map

package/dist/commands/helpers/smart-element.d.ts

@@ -1,16 +0,0 @@
-export type SmartElementType = 'dialog' | 'details' | 'select' | null;
-export type DialogMode = 'modal' | 'non-modal';
-export declare function detectSmartElementType(elements: HTMLElement[]): SmartElementType;
-export declare function resolveSmartElementTargets(elements: HTMLElement[]): HTMLElement[];
-export declare function toggleDialog(dialog: HTMLDialogElement, mode: DialogMode): void;
-export declare function toggleDetails(details: HTMLDetailsElement): void;
-export declare function toggleSelect(select: HTMLSelectElement): void;
-export declare function toggleSmartElement(element: HTMLElement, type: SmartElementType, options?: {
-    dialogMode?: DialogMode;
-}): boolean;
-export declare function isSmartElement(element: HTMLElement): boolean;
-export declare function isDialogElement(element: HTMLElement): element is HTMLDialogElement;
-export declare function isDetailsElement(element: HTMLElement): element is HTMLDetailsElement;
-export declare function isSelectElement(element: HTMLElement): element is HTMLSelectElement;
-export declare function isSummaryElement(element: HTMLElement): boolean;
-//# sourceMappingURL=smart-element.d.ts.map

package/dist/commands/helpers/style-manipulation.d.ts

@@ -1,16 +0,0 @@
-export type ToggleableCSSProperty = 'display' | 'visibility' | 'opacity';
-export interface ParsedCSSProperty {
-    property: string;
-    value?: string;
-}
-export declare function parseCSSProperty(expression: string): ParsedCSSProperty | null;
-export declare function isCSSPropertySyntax(value: string): boolean;
-export declare function parseToggleableCSSProperty(expression: string): ToggleableCSSProperty | null;
-export declare function getComputedStyleValue(element: HTMLElement, property: string): string;
-export declare function setStyleValue(element: HTMLElement, property: string, value: string): void;
-export declare function removeStyleProperty(element: HTMLElement, property: string): void;
-export declare function toggleCSSProperty(element: HTMLElement, property: ToggleableCSSProperty): void;
-export declare function isDisplayNone(element: HTMLElement): boolean;
-export declare function isVisibilityHidden(element: HTMLElement): boolean;
-export declare function isOpacityZero(element: HTMLElement): boolean;
-//# sourceMappingURL=style-manipulation.d.ts.map

package/dist/commands/helpers/target-elements.d.ts

@@ -1,5 +0,0 @@
-export declare function resolveTargetElements(matches: unknown, selector: unknown, fromQuery?: boolean): unknown;
-export declare function queryTargetElements(selector: string): HTMLElement[];
-export declare function toElementListFiltered(value: unknown): HTMLElement[] | null;
-export declare function toElementListStrict(value: unknown): HTMLElement[] | null;
-//# sourceMappingURL=target-elements.d.ts.map

package/dist/commands/helpers/temporal-modifiers.d.ts

@@ -1,15 +0,0 @@
-export type ToggleType = 'class' | 'attribute';
-export type CleanupFn = () => void;
-export declare function createReversionFn(element: HTMLElement, toggleType: ToggleType, identifier: string): () => void;
-export declare function setupDurationReversion(element: HTMLElement, toggleType: ToggleType, identifier: string, duration: number): CleanupFn;
-export declare function setupEventReversion(element: HTMLElement, toggleType: ToggleType, identifier: string, eventName: string): CleanupFn;
-export interface TemporalModifierOptions {
-    element: HTMLElement;
-    toggleType: ToggleType;
-    identifier: string;
-    duration?: number;
-    untilEvent?: string;
-}
-export declare function setupTemporalModifiers(options: TemporalModifierOptions): CleanupFn[];
-export declare function setupTemporalModifiersForElements(elements: HTMLElement[], toggleType: ToggleType, identifier: string, duration?: number, untilEvent?: string): CleanupFn;
-//# sourceMappingURL=temporal-modifiers.d.ts.map

package/dist/commands/helpers/url-argument-parser.d.ts

@@ -1,13 +0,0 @@
-import type { ExecutionContext, ExpressionNode } from '../../types/core';
-import type { ASTNode } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export interface UrlCommandInput {
-    url: string;
-    title?: string;
-    state?: Record<string, unknown>;
-}
-export declare function parseUrlArguments(raw: {
-    args: ASTNode[];
-    modifiers?: Record<string, ExpressionNode>;
-}, evaluator: ExpressionEvaluator, context: ExecutionContext, commandName: string): Promise<UrlCommandInput>;
-//# sourceMappingURL=url-argument-parser.d.ts.map

package/dist/commands/helpers/url-validation.d.ts

@@ -1,7 +0,0 @@
-export declare function validateUrl(url: unknown, commandName: string, debugInfo?: string): string;
-export declare function isExternalUrl(url: string): boolean;
-export declare function isSafeUrl(url: string): boolean;
-export declare function normalizeUrl(url: string): string;
-export declare function extractSearchParams(url: string): URLSearchParams;
-export declare function buildUrlWithParams(basePath: string, params: Record<string, string> | URLSearchParams | FormData): string;
-//# sourceMappingURL=url-validation.d.ts.map

package/dist/commands/helpers/variable-access.d.ts

@@ -1,13 +0,0 @@
-import type { ExecutionContext } from '../../types/base-types';
-export declare function convertToNumber(value: unknown): number;
-export declare function counterAmount(value: unknown): number;
-export declare function counterValue(value: unknown): number;
-export declare function getVariableValue(name: string, context: ExecutionContext, preferredScope?: string): unknown;
-export declare function setVariableValue(name: string, value: unknown, context: ExecutionContext, preferredScope?: string): void;
-export declare function resolveElementRef(elementRef: string, context: ExecutionContext): unknown;
-export declare function getElementPropertyValue(propertyPath: string, context: ExecutionContext): number;
-export declare function setElementPropertyValue(propertyPath: string, value: unknown, context: ExecutionContext): void;
-export declare function isObjectOwner(value: unknown): value is Record<string, unknown>;
-export declare function getCurrentNumericValue(target: string | HTMLElement | number | Record<string, unknown>, property: string | undefined, scope: string | undefined, context: ExecutionContext): number;
-export declare function setTargetValue(target: string | HTMLElement | number | Record<string, unknown>, property: string | undefined, scope: string | undefined, newValue: unknown, context: ExecutionContext): void;
-//# sourceMappingURL=variable-access.d.ts.map

package/dist/commands/helpers/visibility-target-parser.d.ts

@@ -1,15 +0,0 @@
-import type { ASTNode, ExecutionContext, ExpressionNode } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-export interface VisibilityRawInput {
-    args: ASTNode[];
-    modifiers: Record<string, ExpressionNode>;
-}
-export interface VisibilityInput {
-    targets: HTMLElement[];
-}
-export declare function parseVisibilityInput(raw: VisibilityRawInput, evaluator: ExpressionEvaluator, context: ExecutionContext, commandName: string): Promise<VisibilityInput>;
-export declare function partitionByCondition(targets: HTMLElement[], condition: ASTNode, evaluator: ExpressionEvaluator, context: ExecutionContext): Promise<{
-    matched: HTMLElement[];
-    unmatched: HTMLElement[];
-}>;
-//# sourceMappingURL=visibility-target-parser.d.ts.map

package/dist/commands/helpers/write-target.d.ts

@@ -1,42 +0,0 @@
-import type { ExecutionContext } from '../../types/core';
-import type { ASTNode } from '../../types/base-types';
-import type { ExpressionEvaluator } from '../../core/expression-evaluator';
-import { type PropertyTarget } from './property-target';
-import { type NodeWriterFn } from '../../parser/extensions';
-export type WriteTarget = {
-    kind: 'node-write';
-    node: ASTNode;
-    writer: NodeWriterFn;
-} | {
-    kind: 'selector';
-    selector: string;
-} | {
-    kind: 'attribute';
-    elements: HTMLElement[];
-    name: string;
-} | {
-    kind: 'style';
-    element: HTMLElement;
-    property: string;
-} | {
-    kind: 'property';
-    target: PropertyTarget;
-} | {
-    kind: 'member';
-    container: Record<string, unknown>;
-    property: string;
-} | {
-    kind: 'variable';
-    name: string;
-    scope?: 'element' | 'global';
-};
-export interface WriteTargetOptions {
-    scopeElements: () => Promise<HTMLElement[]>;
-    nodeWriters?: boolean;
-    selectorSource?: boolean;
-    styleSplit?: boolean;
-    ofAndObjectProperty?: boolean;
-    bareReference?: boolean;
-}
-export declare function resolveWriteTarget(node: ASTNode | Record<string, unknown> | undefined, evaluator: ExpressionEvaluator, context: ExecutionContext, options: WriteTargetOptions): Promise<WriteTarget | null>;
-//# sourceMappingURL=write-target.d.ts.map