@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.2

package/dist/index-DDVME65c.d.ts

@@ -0,0 +1,919 @@
+//#region src/yoga/generated/YGEnums.d.ts
+declare const Align: {
+  readonly Auto: 0;
+  readonly FlexStart: 1;
+  readonly Center: 2;
+  readonly FlexEnd: 3;
+  readonly Stretch: 4;
+  readonly Baseline: 5;
+  readonly SpaceBetween: 6;
+  readonly SpaceAround: 7;
+  readonly SpaceEvenly: 8;
+  readonly Start: 9;
+  readonly End: 10;
+};
+type Align = (typeof Align)[keyof typeof Align];
+declare const BoxSizing: {
+  readonly BorderBox: 0;
+  readonly ContentBox: 1;
+};
+type BoxSizing = (typeof BoxSizing)[keyof typeof BoxSizing];
+declare const Dimension: {
+  readonly Width: 0;
+  readonly Height: 1;
+};
+type Dimension = (typeof Dimension)[keyof typeof Dimension];
+declare const Direction: {
+  readonly Inherit: 0;
+  readonly LTR: 1;
+  readonly RTL: 2;
+};
+type Direction = (typeof Direction)[keyof typeof Direction];
+declare const Display: {
+  readonly Flex: 0;
+  readonly None: 1;
+  readonly Contents: 2;
+  readonly Grid: 3;
+};
+type Display = (typeof Display)[keyof typeof Display];
+declare const Edge: {
+  readonly Left: 0;
+  readonly Top: 1;
+  readonly Right: 2;
+  readonly Bottom: 3;
+  readonly Start: 4;
+  readonly End: 5;
+  readonly Horizontal: 6;
+  readonly Vertical: 7;
+  readonly All: 8;
+};
+type Edge = (typeof Edge)[keyof typeof Edge];
+declare const Errata: {
+  readonly None: 0;
+  readonly StretchFlexBasis: 1;
+  readonly AbsolutePositionWithoutInsetsExcludesPadding: 2;
+  readonly AbsolutePercentAgainstInnerSize: 4;
+  readonly MinSizeUndefinedInsteadOfAuto: 8;
+  readonly All: 2147483647;
+  readonly Classic: 2147483646;
+};
+type Errata = number;
+declare const ExperimentalFeature: {
+  readonly WebFlexBasis: 0;
+  readonly FixFlexBasisFitContent: 1;
+};
+type ExperimentalFeature = (typeof ExperimentalFeature)[keyof typeof ExperimentalFeature];
+declare const FlexDirection: {
+  readonly Column: 0;
+  readonly ColumnReverse: 1;
+  readonly Row: 2;
+  readonly RowReverse: 3;
+};
+type FlexDirection = (typeof FlexDirection)[keyof typeof FlexDirection];
+declare const GridTrackType: {
+  readonly Auto: 0;
+  readonly Points: 1;
+  readonly Percent: 2;
+  readonly Fr: 3;
+  readonly Minmax: 4;
+};
+type GridTrackType = (typeof GridTrackType)[keyof typeof GridTrackType];
+declare const Gutter: {
+  readonly Column: 0;
+  readonly Row: 1;
+  readonly All: 2;
+};
+type Gutter = (typeof Gutter)[keyof typeof Gutter];
+declare const Justify: {
+  readonly Auto: 0;
+  readonly FlexStart: 1;
+  readonly Center: 2;
+  readonly FlexEnd: 3;
+  readonly SpaceBetween: 4;
+  readonly SpaceAround: 5;
+  readonly SpaceEvenly: 6;
+  readonly Stretch: 7;
+  readonly Start: 8;
+  readonly End: 9;
+};
+type Justify = (typeof Justify)[keyof typeof Justify];
+declare const LogLevel: {
+  readonly Error: 0;
+  readonly Warn: 1;
+  readonly Info: 2;
+  readonly Debug: 3;
+  readonly Verbose: 4;
+  readonly Fatal: 5;
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+declare const MeasureMode: {
+  readonly Undefined: 0;
+  readonly Exactly: 1;
+  readonly AtMost: 2;
+};
+type MeasureMode = (typeof MeasureMode)[keyof typeof MeasureMode];
+declare const NodeType: {
+  readonly Default: 0;
+  readonly Text: 1;
+};
+type NodeType = (typeof NodeType)[keyof typeof NodeType];
+declare const Overflow: {
+  readonly Visible: 0;
+  readonly Hidden: 1;
+  readonly Scroll: 2;
+};
+type Overflow = (typeof Overflow)[keyof typeof Overflow];
+declare const PositionType: {
+  readonly Static: 0;
+  readonly Relative: 1;
+  readonly Absolute: 2;
+};
+type PositionType = (typeof PositionType)[keyof typeof PositionType];
+declare const Unit: {
+  readonly Undefined: 0;
+  readonly Point: 1;
+  readonly Percent: 2;
+  readonly Auto: 3;
+  readonly MaxContent: 4;
+  readonly FitContent: 5;
+  readonly Stretch: 6;
+};
+type Unit = (typeof Unit)[keyof typeof Unit];
+declare const Wrap: {
+  readonly NoWrap: 0;
+  readonly Wrap: 1;
+  readonly WrapReverse: 2;
+};
+type Wrap = (typeof Wrap)[keyof typeof Wrap];
+declare const constants: {
+  ALIGN_AUTO: 0;
+  ALIGN_FLEX_START: 1;
+  ALIGN_CENTER: 2;
+  ALIGN_FLEX_END: 3;
+  ALIGN_STRETCH: 4;
+  ALIGN_BASELINE: 5;
+  ALIGN_SPACE_BETWEEN: 6;
+  ALIGN_SPACE_AROUND: 7;
+  ALIGN_SPACE_EVENLY: 8;
+  ALIGN_START: 9;
+  ALIGN_END: 10;
+  BOX_SIZING_BORDER_BOX: 0;
+  BOX_SIZING_CONTENT_BOX: 1;
+  DIMENSION_WIDTH: 0;
+  DIMENSION_HEIGHT: 1;
+  DIRECTION_INHERIT: 0;
+  DIRECTION_LTR: 1;
+  DIRECTION_RTL: 2;
+  DISPLAY_FLEX: 0;
+  DISPLAY_NONE: 1;
+  DISPLAY_CONTENTS: 2;
+  DISPLAY_GRID: 3;
+  EDGE_LEFT: 0;
+  EDGE_TOP: 1;
+  EDGE_RIGHT: 2;
+  EDGE_BOTTOM: 3;
+  EDGE_START: 4;
+  EDGE_END: 5;
+  EDGE_HORIZONTAL: 6;
+  EDGE_VERTICAL: 7;
+  EDGE_ALL: 8;
+  ERRATA_NONE: 0;
+  ERRATA_STRETCH_FLEX_BASIS: 1;
+  ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING: 2;
+  ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE: 4;
+  ERRATA_MIN_SIZE_UNDEFINED_INSTEAD_OF_AUTO: 8;
+  ERRATA_ALL: 2147483647;
+  ERRATA_CLASSIC: 2147483646;
+  EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: 0;
+  EXPERIMENTAL_FEATURE_FIX_FLEX_BASIS_FIT_CONTENT: 1;
+  FLEX_DIRECTION_COLUMN: 0;
+  FLEX_DIRECTION_COLUMN_REVERSE: 1;
+  FLEX_DIRECTION_ROW: 2;
+  FLEX_DIRECTION_ROW_REVERSE: 3;
+  GRID_TRACK_TYPE_AUTO: 0;
+  GRID_TRACK_TYPE_POINTS: 1;
+  GRID_TRACK_TYPE_PERCENT: 2;
+  GRID_TRACK_TYPE_FR: 3;
+  GRID_TRACK_TYPE_MINMAX: 4;
+  GUTTER_COLUMN: 0;
+  GUTTER_ROW: 1;
+  GUTTER_ALL: 2;
+  JUSTIFY_AUTO: 0;
+  JUSTIFY_FLEX_START: 1;
+  JUSTIFY_CENTER: 2;
+  JUSTIFY_FLEX_END: 3;
+  JUSTIFY_SPACE_BETWEEN: 4;
+  JUSTIFY_SPACE_AROUND: 5;
+  JUSTIFY_SPACE_EVENLY: 6;
+  JUSTIFY_STRETCH: 7;
+  JUSTIFY_START: 8;
+  JUSTIFY_END: 9;
+  LOG_LEVEL_ERROR: 0;
+  LOG_LEVEL_WARN: 1;
+  LOG_LEVEL_INFO: 2;
+  LOG_LEVEL_DEBUG: 3;
+  LOG_LEVEL_VERBOSE: 4;
+  LOG_LEVEL_FATAL: 5;
+  MEASURE_MODE_UNDEFINED: 0;
+  MEASURE_MODE_EXACTLY: 1;
+  MEASURE_MODE_AT_MOST: 2;
+  NODE_TYPE_DEFAULT: 0;
+  NODE_TYPE_TEXT: 1;
+  OVERFLOW_VISIBLE: 0;
+  OVERFLOW_HIDDEN: 1;
+  OVERFLOW_SCROLL: 2;
+  POSITION_TYPE_STATIC: 0;
+  POSITION_TYPE_RELATIVE: 1;
+  POSITION_TYPE_ABSOLUTE: 2;
+  UNIT_UNDEFINED: 0;
+  UNIT_POINT: 1;
+  UNIT_PERCENT: 2;
+  UNIT_AUTO: 3;
+  UNIT_MAX_CONTENT: 4;
+  UNIT_FIT_CONTENT: 5;
+  UNIT_STRETCH: 6;
+  WRAP_NO_WRAP: 0;
+  WRAP_WRAP: 1;
+  WRAP_WRAP_REVERSE: 2;
+};
+//#endregion
+//#region src/yoga/core/config.d.ts
+declare class Config$1 {
+  private useWebDefaults_;
+  private version_;
+  private experimentalFeatures_;
+  private errata_;
+  private pointScaleFactor_;
+  setUseWebDefaults(useWebDefaults: boolean): void;
+  useWebDefaults(): boolean;
+  setExperimentalFeatureEnabled(feature: ExperimentalFeature, enabled: boolean): void;
+  isExperimentalFeatureEnabled(feature: ExperimentalFeature): boolean;
+  getEnabledExperiments(): number;
+  setErrata(errata: Errata): void;
+  addErrata(errata: Errata): void;
+  removeErrata(errata: Errata): void;
+  getErrata(): Errata;
+  hasErrata(errata: Errata): boolean;
+  setPointScaleFactor(pointScaleFactor: number): void;
+  getPointScaleFactor(): number;
+  getVersion(): number;
+}
+//#endregion
+//#region src/yoga/config.d.ts
+/**
+ * Public Config wrapper over the core config, exposing the same surface as
+ * the WASM binding's ConfigImpl.
+ */
+declare class Config {
+  /** @internal */
+  core: Config$1;
+  static create(): Config;
+  /**
+      @deprecated No-op in the TypeScript port: the garbage collector owns this
+      config's lifetime. Kept only for yoga-layout binding compatibility.
+      */
+  free(): void;
+  setExperimentalFeatureEnabled(feature: ExperimentalFeature, enabled: boolean): void;
+  isExperimentalFeatureEnabled(feature: ExperimentalFeature): boolean;
+  setPointScaleFactor(factor: number): void;
+  getErrata(): Errata;
+  setErrata(errata: Errata): void;
+  useWebDefaults(): boolean;
+  setUseWebDefaults(useWebDefaults: boolean): void;
+}
+//#endregion
+//#region src/yoga/core/helpers.d.ts
+declare const PhysicalEdge: {
+  readonly Left: 0;
+  readonly Top: 1;
+  readonly Right: 2;
+  readonly Bottom: 3;
+};
+type PhysicalEdge = (typeof PhysicalEdge)[keyof typeof PhysicalEdge];
+declare const SizingMode: {
+  readonly StretchFit: 0;
+  readonly MaxContent: 1;
+  readonly FitContent: 2;
+};
+type SizingMode = (typeof SizingMode)[keyof typeof SizingMode];
+//#endregion
+//#region src/yoga/core/flexLine.d.ts
+interface FlexLineRunningLayout {
+  totalFlexGrowFactors: number;
+  totalFlexShrinkScaledFactors: number;
+  remainingFreeSpace: number;
+  mainDim: number;
+  crossDim: number;
+}
+interface FlexLine {
+  itemsInFlow: Node$1[];
+  sizeConsumed: number;
+  numberOfAutoMargins: number;
+  endIndex: number;
+  layout: FlexLineRunningLayout;
+}
+//#endregion
+//#region src/yoga/core/layoutResults.d.ts
+declare class CachedMeasurement {
+  availableWidth: number;
+  availableHeight: number;
+  widthSizingMode: SizingMode;
+  heightSizingMode: SizingMode;
+  computedWidth: number;
+  computedHeight: number;
+  equals(measurement: CachedMeasurement): boolean;
+}
+declare class LayoutResults {
+  static readonly MaxCachedMeasurements = 8;
+  computedFlexBasisGeneration: number;
+  computedFlexBasis: number;
+  computedAutoMinMainSize: number;
+  generationCount: number;
+  configVersion: number;
+  lastOwnerDirection: Direction;
+  nextCachedMeasurementsIndex: number;
+  cachedMeasurements: CachedMeasurement[];
+  roundingDirty: boolean;
+  roundedAbsLeft: number;
+  roundedAbsTop: number;
+  roundedScale: number;
+  cachedLayout: CachedMeasurement;
+  flexLine: FlexLine | null;
+  flexLineStarts: number[] | null;
+  private direction_;
+  private hadOverflow_;
+  private values_;
+  direction(): Direction;
+  setDirection(direction: Direction): void;
+  hadOverflow(): boolean;
+  setHadOverflow(hadOverflow: boolean): void;
+  dimension(axis: Dimension): number;
+  setDimension(axis: Dimension, dimension: number): void;
+  measuredDimension(axis: Dimension): number;
+  rawDimension(axis: Dimension): number;
+  setMeasuredDimension(axis: Dimension, dimension: number): void;
+  setRawDimension(axis: Dimension, dimension: number): void;
+  position(physicalEdge: PhysicalEdge): number;
+  setPosition(physicalEdge: PhysicalEdge, dimension: number): void;
+  margin(physicalEdge: PhysicalEdge): number;
+  setMargin(physicalEdge: PhysicalEdge, dimension: number): void;
+  border(physicalEdge: PhysicalEdge): number;
+  setBorder(physicalEdge: PhysicalEdge, dimension: number): void;
+  padding(physicalEdge: PhysicalEdge): number;
+  setPadding(physicalEdge: PhysicalEdge, dimension: number): void;
+}
+//#endregion
+//#region src/yoga/core/types.d.ts
+/**
+ * A CSS <length-percentage> or keyword. `value` is NaN for keyword units.
+ * Instances are immutable and may be shared.
+ */
+declare class StyleLength {
+  readonly value: number;
+  readonly unit: Unit;
+  protected constructor(value: number, unit: Unit);
+  static points(value: number): StyleLength;
+  static percent(value: number): StyleLength;
+  static ofAuto(): StyleLength;
+  static undefined(): StyleLength;
+  isAuto(): boolean;
+  isUndefined(): boolean;
+  isDefined(): boolean;
+  isPoints(): boolean;
+  isPercent(): boolean;
+  resolve(referenceLength: number): number;
+  equals(other: StyleLength): boolean;
+  inexactEquals(other: StyleLength): boolean;
+}
+/**
+ * A CSS value for sizes (width, min-width, flex-basis, ...) which additionally
+ * allows the auto/max-content/fit-content/stretch keywords.
+ */
+declare class StyleSizeLength {
+  readonly value: number;
+  readonly unit: Unit;
+  protected constructor(value: number, unit: Unit);
+  static points(value: number): StyleSizeLength;
+  static percent(value: number): StyleSizeLength;
+  static ofAuto(): StyleSizeLength;
+  static ofMaxContent(): StyleSizeLength;
+  static ofFitContent(): StyleSizeLength;
+  static ofStretch(): StyleSizeLength;
+  static undefined(): StyleSizeLength;
+  isAuto(): boolean;
+  isMaxContent(): boolean;
+  isFitContent(): boolean;
+  isStretch(): boolean;
+  isUndefined(): boolean;
+  isDefined(): boolean;
+  isPoints(): boolean;
+  isPercent(): boolean;
+  resolve(referenceLength: number): number;
+  equals(other: StyleSizeLength): boolean;
+  inexactEquals(other: StyleSizeLength): boolean;
+}
+interface Size$1 {
+  width: number;
+  height: number;
+}
+//#endregion
+//#region src/yoga/core/style.d.ts
+declare class Style {
+  static readonly DefaultFlexGrow = 0;
+  static readonly DefaultFlexShrink = 0;
+  static readonly WebDefaultFlexShrink = 1;
+  private direction_;
+  private flexDirection_;
+  private justifyContent_;
+  private justifyItems_;
+  private justifySelf_;
+  private alignContent_;
+  private alignItems_;
+  private alignSelf_;
+  private positionType_;
+  private flexWrap_;
+  private overflow_;
+  private display_;
+  private boxSizing_;
+  private flex_;
+  private flexGrow_;
+  private flexShrink_;
+  private flexBasis_;
+  private margin_;
+  private position_;
+  private padding_;
+  private border_;
+  private gap_;
+  private marginResolved_;
+  private positionResolved_;
+  private paddingResolved_;
+  private borderResolved_;
+  private dimensions_;
+  private aspectRatio_;
+  direction(): Direction;
+  setDirection(value: Direction): void;
+  flexDirection(): FlexDirection;
+  setFlexDirection(value: FlexDirection): void;
+  justifyContent(): Justify;
+  setJustifyContent(value: Justify): void;
+  justifyItems(): Justify;
+  setJustifyItems(value: Justify): void;
+  justifySelf(): Justify;
+  setJustifySelf(value: Justify): void;
+  alignContent(): Align;
+  setAlignContent(value: Align): void;
+  alignItems(): Align;
+  setAlignItems(value: Align): void;
+  alignSelf(): Align;
+  setAlignSelf(value: Align): void;
+  positionType(): PositionType;
+  setPositionType(value: PositionType): void;
+  flexWrap(): Wrap;
+  setFlexWrap(value: Wrap): void;
+  overflow(): Overflow;
+  setOverflow(value: Overflow): void;
+  display(): Display;
+  setDisplay(value: Display): void;
+  flex(): number;
+  setFlex(value: number): void;
+  flexGrow(): number;
+  setFlexGrow(value: number): void;
+  flexShrink(): number;
+  setFlexShrink(value: number): void;
+  flexBasis(): StyleSizeLength;
+  setFlexBasis(value: StyleSizeLength): void;
+  margin(edge: Edge): StyleLength;
+  setMargin(edge: Edge, value: StyleLength): void;
+  position(edge: Edge): StyleLength;
+  setPosition(edge: Edge, value: StyleLength): void;
+  padding(edge: Edge): StyleLength;
+  setPadding(edge: Edge, value: StyleLength): void;
+  border(edge: Edge): StyleLength;
+  setBorder(edge: Edge, value: StyleLength): void;
+  gap(gutter: Gutter): StyleLength;
+  setGap(gutter: Gutter, value: StyleLength): void;
+  dimension(axis: Dimension): StyleSizeLength;
+  setDimension(axis: Dimension, value: StyleSizeLength): void;
+  minDimension(axis: Dimension): StyleSizeLength;
+  setMinDimension(axis: Dimension, value: StyleSizeLength): void;
+  maxDimension(axis: Dimension): StyleSizeLength;
+  setMaxDimension(axis: Dimension, value: StyleSizeLength): void;
+  resolvedMinDimension(direction: Direction, axis: Dimension, referenceLength: number, ownerWidth: number): number;
+  resolvedMaxDimension(direction: Direction, axis: Dimension, referenceLength: number, ownerWidth: number): number;
+  aspectRatio(): number;
+  setAspectRatio(value: number): void;
+  boxSizing(): BoxSizing;
+  setBoxSizing(value: BoxSizing): void;
+  horizontalInsetsDefined(): boolean;
+  verticalInsetsDefined(): boolean;
+  hasPositionOrMargin(): boolean;
+  hasPaddingOrBorder(): boolean;
+  isFlexStartPositionDefined(axis: FlexDirection, direction: Direction): boolean;
+  isFlexStartPositionAuto(axis: FlexDirection, direction: Direction): boolean;
+  isInlineStartPositionDefined(axis: FlexDirection, direction: Direction): boolean;
+  isInlineStartPositionAuto(axis: FlexDirection, direction: Direction): boolean;
+  isFlexEndPositionDefined(axis: FlexDirection, direction: Direction): boolean;
+  isFlexEndPositionAuto(axis: FlexDirection, direction: Direction): boolean;
+  isInlineEndPositionDefined(axis: FlexDirection, direction: Direction): boolean;
+  isInlineEndPositionAuto(axis: FlexDirection, direction: Direction): boolean;
+  computeFlexStartPosition(axis: FlexDirection, direction: Direction, axisSize: number): number;
+  computeInlineStartPosition(axis: FlexDirection, direction: Direction, axisSize: number): number;
+  computeFlexEndPosition(axis: FlexDirection, direction: Direction, axisSize: number): number;
+  computeInlineEndPosition(axis: FlexDirection, direction: Direction, axisSize: number): number;
+  computeFlexStartMargin(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeInlineStartMargin(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeFlexEndMargin(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeInlineEndMargin(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeFlexStartBorder(axis: FlexDirection, direction: Direction): number;
+  computeInlineStartBorder(axis: FlexDirection, direction: Direction): number;
+  computeFlexEndBorder(axis: FlexDirection, direction: Direction): number;
+  computeInlineEndBorder(axis: FlexDirection, direction: Direction): number;
+  computeFlexStartPadding(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeInlineStartPadding(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeFlexEndPadding(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeInlineEndPadding(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeInlineStartPaddingAndBorder(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeFlexStartPaddingAndBorder(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeInlineEndPaddingAndBorder(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computeFlexEndPaddingAndBorder(axis: FlexDirection, direction: Direction, widthSize: number): number;
+  computePaddingAndBorderForDimension(direction: Direction, dimension: Dimension, widthSize: number): number;
+  computeBorderForAxis(axis: FlexDirection): number;
+  computeMarginForAxis(axis: FlexDirection, widthSize: number): number;
+  computeGapForAxis(axis: FlexDirection, ownerSize: number): number;
+  computeGapForDimension(dimension: Dimension, ownerSize: number): number;
+  flexStartMarginIsAuto(axis: FlexDirection, direction: Direction): boolean;
+  flexEndMarginIsAuto(axis: FlexDirection, direction: Direction): boolean;
+  inlineStartMarginIsAuto(axis: FlexDirection, direction: Direction): boolean;
+  inlineEndMarginIsAuto(axis: FlexDirection, direction: Direction): boolean;
+  equals(other: Style): boolean;
+  copyFrom(other: Style): void;
+  private computeColumnGap;
+  private computeRowGap;
+  private computeLeftEdge;
+  private computeTopEdge;
+  private computeRightEdge;
+  private computeBottomEdge;
+  private buildResolvedEdges;
+  private resolvedPosition;
+  private resolvedMargin;
+  private resolvedPadding;
+  private resolvedBorder;
+  computePosition(edge: PhysicalEdge, direction: Direction): StyleLength;
+  computeMargin(edge: PhysicalEdge, direction: Direction): StyleLength;
+  computePadding(edge: PhysicalEdge, direction: Direction): StyleLength;
+  computeBorder(edge: PhysicalEdge, direction: Direction): StyleLength;
+}
+//#endregion
+//#region src/yoga/core/node.d.ts
+type MeasureFunc = (width: number, widthMode: MeasureMode, height: number, heightMode: MeasureMode) => Size$1;
+type BaselineFunc = (width: number, height: number) => number;
+type DirtiedFunc = () => void;
+declare class Node$1 {
+  hasNewLayout_: boolean;
+  isReferenceBaseline_: boolean;
+  private isDirty_;
+  alwaysFormsContainingBlock: boolean;
+  nodeType: NodeType;
+  private measureFunc_;
+  private measureResult_;
+  private baselineFunc_;
+  private dirtiedFunc_;
+  style: Style;
+  layout: LayoutResults;
+  lineIndex: number;
+  private contentsChildrenCount_;
+  owner: Node$1 | null;
+  children: Node$1[];
+  config: Config$1;
+  private processedDimensionWidth_;
+  private processedDimensionHeight_;
+  private dimensionsDirty_;
+  constructor(config?: Config$1);
+  hasMeasureFunc(): boolean;
+  measure(availableWidth: number, widthMode: MeasureMode, availableHeight: number, heightMode: MeasureMode): Size$1;
+  hasBaselineFunc(): boolean;
+  baseline(width: number, height: number): number;
+  getDirtiedFunc(): DirtiedFunc | null;
+  dimensionWithMargin(axis: FlexDirection, widthSize: number): number;
+  isLayoutDimensionDefined(axis: FlexDirection): boolean;
+  /**
+   * Whether the node has a "definite length" along the given axis.
+   * https://www.w3.org/TR/css-sizing-3/#definite
+   */
+  hasDefiniteLength(dim: Dimension, ownerSize: number): boolean;
+  hasErrata(errata: number): boolean;
+  hasContentsChildren(): boolean;
+  getChildCount(): number;
+  getChild(index: number): Node$1;
+  /**
+   * Children for layout purposes: skips display: contents nodes, splicing
+   * their children in place. Returns the raw children array when nothing
+   * needs splicing — do not mutate the result.
+   */
+  getLayoutChildren(): readonly Node$1[];
+  getLayoutChildCount(): number;
+  isDirty(): boolean;
+  getProcessedDimension(dim: Dimension): StyleSizeLength;
+  getResolvedDimension(direction: Direction, dim: Dimension, referenceLength: number, ownerWidth: number): number;
+  setMeasureFunc(measureFunc: MeasureFunc | null): void;
+  setBaselineFunc(baselineFunc: BaselineFunc | null): void;
+  setCoreDirtiedFunc(dirtiedFunc: DirtiedFunc | null): void;
+  insertChild(child: Node$1, index: number): void;
+  setConfig(config: Config$1): void;
+  setDirty(isDirty: boolean): void;
+  setChildren(children: Node$1[]): void;
+  removeChild(child: Node$1): boolean;
+  removeChildAtIndex(index: number): void;
+  clearChildren(): void;
+  syncContentsChildrenCount(): void;
+  setLayoutDirection(direction: Direction): void;
+  setLayoutMargin(margin: number, edge: PhysicalEdge): void;
+  setLayoutBorder(border: number, edge: PhysicalEdge): void;
+  setLayoutPadding(padding: number, edge: PhysicalEdge): void;
+  setLayoutLastOwnerDirection(direction: Direction): void;
+  setLayoutComputedFlexBasis(computedFlexBasis: number): void;
+  markLayoutWritten(): void;
+  setLayoutPosition(position: number, edge: PhysicalEdge): void;
+  setLayoutComputedFlexBasisGeneration(computedFlexBasisGeneration: number): void;
+  setLayoutMeasuredDimension(measuredDimension: number, dim: Dimension): void;
+  setLayoutHadOverflow(hadOverflow: boolean): void;
+  setLayoutDimension(lengthValue: number, dim: Dimension): void;
+  relativePosition(axis: FlexDirection, direction: Direction, axisSize: number): number;
+  setPositionFromStyle(direction: Direction, ownerWidth: number, ownerHeight: number): void;
+  processFlexBasis(): StyleSizeLength;
+  resolveFlexBasis(direction: Direction, flexDirection: FlexDirection, referenceLength: number, ownerWidth: number): number;
+  processDimensions(): void;
+  invalidateProcessedDimensions(): void;
+  resolveDirection(ownerDirection: Direction): Direction;
+  cloneChildrenIfNeeded(): void;
+  cloneContentsChildrenIfNeeded(): void;
+  markDirtyAndPropagate(): void;
+  resolveFlexGrow(): number;
+  resolveFlexShrink(): number;
+  isNodeFlexible(): boolean;
+  reset(): void;
+}
+//#endregion
+//#region src/yoga/node.d.ts
+type Layout = {
+  left: number;
+  right: number;
+  top: number;
+  bottom: number;
+  width: number;
+  height: number;
+  hadOverflow: boolean;
+};
+type Size = {
+  width: number;
+  height: number;
+};
+type Value = {
+  unit: Unit;
+  value: number;
+};
+type DirtiedFunction = (node: Node) => void;
+type MeasureFunction = (width: number, widthMode: MeasureMode, height: number, heightMode: MeasureMode) => Size;
+declare class Node extends Node$1 {
+  private constructor();
+  static create(config?: Config): Node;
+  static createDefault(): Node;
+  static createWithConfig(config: Config): Node;
+  /**
+      @deprecated No-op in the TypeScript port: the garbage collector owns this
+      node's lifetime. Kept only for yoga-layout binding compatibility (WASM
+      nodes require explicit destruction).
+      */
+  free(): void;
+  /**
+      @deprecated No-op in the TypeScript port: garbage collection handles
+      object graphs and cycles. Kept only for yoga-layout binding compatibility.
+      */
+  freeRecursive(): void;
+  insertChild(child: Node, index: number): void;
+  removeChild(child: Node): boolean;
+  getChildCount(): number;
+  getChild(index: number): Node;
+  getParent(): Node | null;
+  setChildren(children: Node[]): void;
+  reset(): void;
+  copyStyle(other: Node): void;
+  private updateStyleLength;
+  private updateStyleSize;
+  private updateStyleEnum;
+  private setDimensionValue;
+  private setMinDimensionValue;
+  private setMaxDimensionValue;
+  setPositionType(positionType: PositionType): void;
+  setPosition(edge: Edge, position: number | `${number}%` | undefined): void;
+  setPositionPercent(edge: Edge, position: number | undefined): void;
+  setPositionAuto(edge: Edge): void;
+  setAlignContent(alignContent: Align): void;
+  setAlignItems(alignItems: Align): void;
+  setAlignSelf(alignSelf: Align): void;
+  setFlexDirection(flexDirection: FlexDirection): void;
+  setFlexWrap(flexWrap: Wrap): void;
+  setJustifyContent(justifyContent: Justify): void;
+  setDirection(direction: Direction): void;
+  setMargin(edge: Edge, margin: number | "auto" | `${number}%` | undefined): void;
+  setMarginPercent(edge: Edge, margin: number | undefined): void;
+  setMarginAuto(edge: Edge): void;
+  setOverflow(overflow: Overflow): void;
+  setDisplay(display: Display): void;
+  setFlex(flex: number | undefined): void;
+  setFlexBasis(flexBasis: number | "auto" | "fit-content" | "max-content" | "stretch" | `${number}%` | undefined): void;
+  setFlexBasisPercent(flexBasis: number | undefined): void;
+  setFlexBasisAuto(): void;
+  setFlexBasisMaxContent(): void;
+  setFlexBasisFitContent(): void;
+  setFlexBasisStretch(): void;
+  setFlexGrow(flexGrow: number | undefined): void;
+  setFlexShrink(flexShrink: number | undefined): void;
+  setWidth(width: number | "auto" | "fit-content" | "max-content" | "stretch" | `${number}%` | undefined): void;
+  setWidthPercent(width: number | undefined): void;
+  setWidthAuto(): void;
+  setWidthMaxContent(): void;
+  setWidthFitContent(): void;
+  setWidthStretch(): void;
+  setHeight(height: number | "auto" | "fit-content" | "max-content" | "stretch" | `${number}%` | undefined): void;
+  setHeightPercent(height: number | undefined): void;
+  setHeightAuto(): void;
+  setHeightMaxContent(): void;
+  setHeightFitContent(): void;
+  setHeightStretch(): void;
+  setMinWidth(minWidth: number | "fit-content" | "max-content" | "stretch" | `${number}%` | undefined): void;
+  setMinWidthPercent(minWidth: number | undefined): void;
+  setMinWidthMaxContent(): void;
+  setMinWidthFitContent(): void;
+  setMinWidthStretch(): void;
+  setMinHeight(minHeight: number | "fit-content" | "max-content" | "stretch" | `${number}%` | undefined): void;
+  setMinHeightPercent(minHeight: number | undefined): void;
+  setMinHeightMaxContent(): void;
+  setMinHeightFitContent(): void;
+  setMinHeightStretch(): void;
+  setMaxWidth(maxWidth: number | "fit-content" | "max-content" | "stretch" | `${number}%` | undefined): void;
+  setMaxWidthPercent(maxWidth: number | undefined): void;
+  setMaxWidthMaxContent(): void;
+  setMaxWidthFitContent(): void;
+  setMaxWidthStretch(): void;
+  setMaxHeight(maxHeight: number | "fit-content" | "max-content" | "stretch" | `${number}%` | undefined): void;
+  setMaxHeightPercent(maxHeight: number | undefined): void;
+  setMaxHeightMaxContent(): void;
+  setMaxHeightFitContent(): void;
+  setMaxHeightStretch(): void;
+  setAspectRatio(aspectRatio: number | undefined): void;
+  setBorder(edge: Edge, borderWidth: number | undefined): void;
+  setPadding(edge: Edge, padding: number | `${number}%` | undefined): void;
+  setPaddingPercent(edge: Edge, padding: number | undefined): void;
+  setGap(gutter: Gutter, gapLength: number | `${number}%` | undefined): void;
+  setGapPercent(gutter: Gutter, gapLength: number | undefined): void;
+  setBoxSizing(boxSizing: BoxSizing): void;
+  setIsReferenceBaseline(isReferenceBaseline: boolean): void;
+  setAlwaysFormsContainingBlock(alwaysFormsContainingBlock: boolean): void;
+  getPositionType(): PositionType;
+  getPosition(edge: Edge): Value;
+  getAlignContent(): Align;
+  getAlignItems(): Align;
+  getAlignSelf(): Align;
+  getFlexDirection(): FlexDirection;
+  getFlexWrap(): Wrap;
+  getJustifyContent(): Justify;
+  getDirection(): Direction;
+  getMargin(edge: Edge): Value;
+  getOverflow(): Overflow;
+  getDisplay(): Display;
+  getFlexBasis(): Value;
+  getFlexGrow(): number;
+  getFlexShrink(): number;
+  getWidth(): Value;
+  getHeight(): Value;
+  getMinWidth(): Value;
+  getMinHeight(): Value;
+  getMaxWidth(): Value;
+  getMaxHeight(): Value;
+  getAspectRatio(): number;
+  getBorder(edge: Edge): number;
+  getPadding(edge: Edge): Value;
+  getGap(gutter: Gutter): Value;
+  getBoxSizing(): BoxSizing;
+  isReferenceBaseline(): boolean;
+  setMeasureFunc(measureFunc: MeasureFunction | null): void;
+  unsetMeasureFunc(): void;
+  setDirtiedFunc(dirtiedFunc: DirtiedFunction | null): void;
+  unsetDirtiedFunc(): void;
+  markDirty(): void;
+  isDirty(): boolean;
+  markLayoutSeen(): void;
+  hasNewLayout(): boolean;
+  calculateLayout(width?: number | "auto" | undefined, height?: number | "auto" | undefined, direction?: Direction): void;
+  getComputedLeft(): number;
+  getComputedRight(): number;
+  getComputedTop(): number;
+  getComputedBottom(): number;
+  getComputedWidth(): number;
+  getComputedHeight(): number;
+  getComputedHadOverflow(): boolean;
+  getComputedLayout(): Layout;
+  private resolvedLayoutProperty;
+  getComputedMargin(edge: Edge): number;
+  getComputedBorder(edge: Edge): number;
+  getComputedPadding(edge: Edge): number;
+}
+//#endregion
+//#region src/yoga/index.d.ts
+declare const Yoga: {
+  ALIGN_AUTO: 0;
+  ALIGN_FLEX_START: 1;
+  ALIGN_CENTER: 2;
+  ALIGN_FLEX_END: 3;
+  ALIGN_STRETCH: 4;
+  ALIGN_BASELINE: 5;
+  ALIGN_SPACE_BETWEEN: 6;
+  ALIGN_SPACE_AROUND: 7;
+  ALIGN_SPACE_EVENLY: 8;
+  ALIGN_START: 9;
+  ALIGN_END: 10;
+  BOX_SIZING_BORDER_BOX: 0;
+  BOX_SIZING_CONTENT_BOX: 1;
+  DIMENSION_WIDTH: 0;
+  DIMENSION_HEIGHT: 1;
+  DIRECTION_INHERIT: 0;
+  DIRECTION_LTR: 1;
+  DIRECTION_RTL: 2;
+  DISPLAY_FLEX: 0;
+  DISPLAY_NONE: 1;
+  DISPLAY_CONTENTS: 2;
+  DISPLAY_GRID: 3;
+  EDGE_LEFT: 0;
+  EDGE_TOP: 1;
+  EDGE_RIGHT: 2;
+  EDGE_BOTTOM: 3;
+  EDGE_START: 4;
+  EDGE_END: 5;
+  EDGE_HORIZONTAL: 6;
+  EDGE_VERTICAL: 7;
+  EDGE_ALL: 8;
+  ERRATA_NONE: 0;
+  ERRATA_STRETCH_FLEX_BASIS: 1;
+  ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING: 2;
+  ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE: 4;
+  ERRATA_MIN_SIZE_UNDEFINED_INSTEAD_OF_AUTO: 8;
+  ERRATA_ALL: 2147483647;
+  ERRATA_CLASSIC: 2147483646;
+  EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: 0;
+  EXPERIMENTAL_FEATURE_FIX_FLEX_BASIS_FIT_CONTENT: 1;
+  FLEX_DIRECTION_COLUMN: 0;
+  FLEX_DIRECTION_COLUMN_REVERSE: 1;
+  FLEX_DIRECTION_ROW: 2;
+  FLEX_DIRECTION_ROW_REVERSE: 3;
+  GRID_TRACK_TYPE_AUTO: 0;
+  GRID_TRACK_TYPE_POINTS: 1;
+  GRID_TRACK_TYPE_PERCENT: 2;
+  GRID_TRACK_TYPE_FR: 3;
+  GRID_TRACK_TYPE_MINMAX: 4;
+  GUTTER_COLUMN: 0;
+  GUTTER_ROW: 1;
+  GUTTER_ALL: 2;
+  JUSTIFY_AUTO: 0;
+  JUSTIFY_FLEX_START: 1;
+  JUSTIFY_CENTER: 2;
+  JUSTIFY_FLEX_END: 3;
+  JUSTIFY_SPACE_BETWEEN: 4;
+  JUSTIFY_SPACE_AROUND: 5;
+  JUSTIFY_SPACE_EVENLY: 6;
+  JUSTIFY_STRETCH: 7;
+  JUSTIFY_START: 8;
+  JUSTIFY_END: 9;
+  LOG_LEVEL_ERROR: 0;
+  LOG_LEVEL_WARN: 1;
+  LOG_LEVEL_INFO: 2;
+  LOG_LEVEL_DEBUG: 3;
+  LOG_LEVEL_VERBOSE: 4;
+  LOG_LEVEL_FATAL: 5;
+  MEASURE_MODE_UNDEFINED: 0;
+  MEASURE_MODE_EXACTLY: 1;
+  MEASURE_MODE_AT_MOST: 2;
+  NODE_TYPE_DEFAULT: 0;
+  NODE_TYPE_TEXT: 1;
+  OVERFLOW_VISIBLE: 0;
+  OVERFLOW_HIDDEN: 1;
+  OVERFLOW_SCROLL: 2;
+  POSITION_TYPE_STATIC: 0;
+  POSITION_TYPE_RELATIVE: 1;
+  POSITION_TYPE_ABSOLUTE: 2;
+  UNIT_UNDEFINED: 0;
+  UNIT_POINT: 1;
+  UNIT_PERCENT: 2;
+  UNIT_AUTO: 3;
+  UNIT_MAX_CONTENT: 4;
+  UNIT_FIT_CONTENT: 5;
+  UNIT_STRETCH: 6;
+  WRAP_NO_WRAP: 0;
+  WRAP_WRAP: 1;
+  WRAP_WRAP_REVERSE: 2;
+  Config: typeof Config;
+  Node: typeof Node;
+};
+type Yoga = typeof Yoga;
+//#endregion
+export { Unit as C, PositionType as S, constants as T, Justify as _, Config as a, NodeType as b, Dimension as c, Edge as d, Errata as f, Gutter as g, GridTrackType as h, Node as i, Direction as l, FlexDirection as m, DirtiedFunction as n, Align as o, ExperimentalFeature as p, MeasureFunction as r, BoxSizing as s, Yoga as t, Display as u, LogLevel as v, Wrap as w, Overflow as x, MeasureMode as y };