@pibbl/core 0.0.1 → 0.0.3-alpha.109.1

package/dist/lib/layout/standalone-kernel.js

@@ -0,0 +1,722 @@
+import { readyLayoutModule } from "./wasm/module.js";
+const NODE_STRIDE = 70;
+const MEASUREMENT_STRIDE = 7;
+const LENGTH_NONE = 0;
+const LENGTH_POINT = 1;
+const LENGTH_PERCENT = 2;
+const LENGTH_AUTO = 3;
+const FLEX_DIRECTIONS = [
+  "row",
+  "row-reverse",
+  "column",
+  "column-reverse"
+];
+const FLEX_WRAPS = ["nowrap", "wrap", "wrap-reverse"];
+const JUSTIFY_CONTENT = [
+  "flex-start",
+  "flex-end",
+  "center",
+  "space-between",
+  "space-around",
+  "space-evenly"
+];
+const ALIGNMENTS = [
+  "stretch",
+  "flex-start",
+  "flex-end",
+  "center",
+  "baseline",
+  "first-baseline",
+  "last-baseline"
+];
+const ALIGN_SELF = [
+  "auto",
+  "stretch",
+  "flex-start",
+  "flex-end",
+  "center",
+  "baseline",
+  "first-baseline",
+  "last-baseline"
+];
+const ALIGN_CONTENT = [
+  "flex-start",
+  "flex-end",
+  "center",
+  "stretch",
+  "space-between",
+  "space-around",
+  "space-evenly"
+];
+const POSITIONS = ["relative", "static", "absolute"];
+const BOX_SIZINGS = ["border-box", "content-box"];
+const GRID_FLOWS = ["row", "column", "row dense", "column dense"];
+function status(value, action) {
+  if (value !== 0)
+    throw new Error(`Standalone native layout ${action} failed (${value}).`);
+}
+function finite(value, property) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new TypeError(
+      `Standalone layout ${property} must be a finite number.`
+    );
+  return value;
+}
+function length(records, offset, value, property) {
+  if (value === void 0) {
+    records[offset] = 0;
+    records[offset + 1] = LENGTH_NONE;
+    return;
+  }
+  if (value === "auto") {
+    records[offset] = 0;
+    records[offset + 1] = LENGTH_AUTO;
+    return;
+  }
+  if (typeof value === "number") {
+    records[offset] = finite(value, property);
+    records[offset + 1] = LENGTH_POINT;
+    return;
+  }
+  if (typeof value === "string" && /^-?(?:\d+|\d*\.\d+)%$/.test(value)) {
+    records[offset] = Number.parseFloat(value);
+    records[offset + 1] = LENGTH_PERCENT;
+    return;
+  }
+  throw new TypeError(
+    `Standalone layout ${property} must be numeric, percentage, auto, or omitted.`
+  );
+}
+function numeric(records, offset, value, fallback, property) {
+  records[offset] = value === void 0 ? fallback : finite(value, property);
+}
+function numericValue(value, fallback, property) {
+  return value === void 0 ? fallback : finite(value, property);
+}
+function enumCode(value, values, fallback, property) {
+  if (value === void 0) return fallback;
+  const index = values.indexOf(value);
+  if (index < 0)
+    throw new TypeError(
+      `Standalone layout ${property} is unsupported by the native tree boundary.`
+    );
+  return index;
+}
+function edge(style, side, property) {
+  const value = style[property];
+  if (value === void 0 || typeof value === "number" || typeof value === "string")
+    return value;
+  if (value !== null && typeof value === "object")
+    return value[side];
+  throw new TypeError(
+    `Standalone layout ${property} must be a scalar or physical-edge record.`
+  );
+}
+class NativeStandaloneLayoutKernel {
+  #kernel;
+  #handle = 0;
+  #generation = 0;
+  constructor() {
+    this.#kernel = new WebAssembly.Instance(readyLayoutModule()).exports;
+    this.#handle = this.kernel.standalone_tree_create();
+    this.#generation = this.#handle ? this.kernel.standalone_tree_generation(this.#handle) : 0;
+    if (!this.#handle || !this.#generation)
+      throw new Error("Standalone native tree allocation failed.");
+  }
+  get kernel() {
+    if (!this.#kernel)
+      throw new Error("The standalone layout kernel has been disposed.");
+    return this.#kernel;
+  }
+  calculate(input) {
+    if (!Number.isFinite(input.width) || input.width < 0 || !Number.isFinite(input.height) || input.height < 0)
+      throw new RangeError(
+        "Standalone layout constraints must be finite and nonnegative."
+      );
+    const nodes = input.nodes;
+    const sourceIndex = /* @__PURE__ */ new Map();
+    for (let index = 0; index < nodes.length; index++) {
+      const id = nodes[index].id;
+      if (!Number.isInteger(id) || id < 0 || sourceIndex.has(id))
+        throw new Error(
+          "Standalone layout node ids must be unique nonnegative integers."
+        );
+      sourceIndex.set(id, index);
+    }
+    const rootIndex = sourceIndex.get(input.root);
+    if (rootIndex === void 0)
+      throw new Error(
+        "Standalone layout root is not present in the owned node set."
+      );
+    const children = [];
+    const pointer = this.kernel.standalone_tree_resize_nodes(
+      this.#handle,
+      this.#generation,
+      nodes.length
+    );
+    if (!pointer && nodes.length)
+      throw new Error("Standalone native node storage allocation failed.");
+    const records = new Float64Array(
+      this.kernel.memory.buffer,
+      pointer,
+      nodes.length * NODE_STRIDE
+    );
+    for (let index = 0; index < nodes.length; index++) {
+      const node = nodes[index];
+      const offset = index * NODE_STRIDE;
+      const style = node.style;
+      const parentIndex = node.parent === void 0 ? -1 : sourceIndex.get(node.parent);
+      if (parentIndex === void 0)
+        throw new Error(
+          "Standalone layout node parent is not present in the owned node set."
+        );
+      const parent = parentIndex < 0 ? void 0 : nodes[parentIndex];
+      const gridContainerDeclaration = style.gridTemplateColumns !== void 0 || style.gridTemplateRows !== void 0 || style.gridAutoColumns !== void 0 || style.gridAutoRows !== void 0 || style.gridAutoFlow !== void 0;
+      const gridItemDeclaration = style.gridColumnStart !== void 0 || style.gridColumnSpan !== void 0 || style.gridRowStart !== void 0 || style.gridRowSpan !== void 0;
+      const flexContainerDeclaration = style.flexDirection !== void 0 || style.flexWrap !== void 0 || style.justifyContent !== void 0 || style.alignContent !== void 0;
+      const flexItemDeclaration = style.flexBasis !== void 0 || style.flexGrow !== void 0 || style.flexShrink !== void 0;
+      if (style.layout !== "grid" && gridContainerDeclaration)
+        throw new TypeError(
+          "Standalone Grid declarations require layout: 'grid'."
+        );
+      if (style.layout === "grid" && flexContainerDeclaration)
+        throw new TypeError(
+          "Standalone Flex-container declarations cannot be applied to a Grid owner."
+        );
+      if (parent === void 0 && style.layout === "grid" && flexItemDeclaration)
+        throw new TypeError(
+          "Standalone Flex item declarations require a Flex parent."
+        );
+      if (parent?.style.layout === "grid" && flexItemDeclaration)
+        throw new TypeError(
+          "Standalone Flex item declarations require a Flex parent."
+        );
+      if (parent?.style.layout !== "grid" && gridItemDeclaration)
+        throw new TypeError(
+          "Standalone Grid item placement requires a Grid parent."
+        );
+      if (style.overflow !== void 0 && style.overflow !== "visible")
+        throw new TypeError(
+          "The standalone native tree does not yet admit clipped overflow."
+        );
+      if (style.alignItems === "baseline" || style.alignItems === "first-baseline" || style.alignItems === "last-baseline" || style.alignSelf === "baseline" || style.alignSelf === "first-baseline" || style.alignSelf === "last-baseline")
+        throw new TypeError("Standalone baseline alignment requires a baseline provider and is not supported.");
+      records[offset] = index;
+      records[offset + 1] = parentIndex;
+      records[offset + 2] = children.length;
+      records[offset + 3] = node.children.length;
+      for (const child of node.children) {
+        const childIndex = sourceIndex.get(child);
+        if (childIndex === void 0)
+          throw new Error(
+            "Standalone layout child is not present in the owned node set."
+          );
+        children.push(childIndex);
+      }
+      length(records, offset + 4, style.width, "width");
+      length(records, offset + 6, style.height, "height");
+      length(records, offset + 8, style.minWidth, "minWidth");
+      length(records, offset + 10, style.minHeight, "minHeight");
+      length(records, offset + 12, style.maxWidth, "maxWidth");
+      length(records, offset + 14, style.maxHeight, "maxHeight");
+      length(records, offset + 16, style.flexBasis, "flexBasis");
+      numeric(records, offset + 18, style.flexGrow, 0, "flexGrow");
+      numeric(records, offset + 19, style.flexShrink, 0, "flexShrink");
+      numeric(records, offset + 20, style.gap, 0, "gap");
+      numeric(records, offset + 21, style.rowGap, -1, "rowGap");
+      numeric(records, offset + 22, style.columnGap, -1, "columnGap");
+      records[offset + 23] = enumCode(
+        style.flexDirection,
+        FLEX_DIRECTIONS,
+        0,
+        "flexDirection"
+      );
+      records[offset + 24] = enumCode(
+        style.flexWrap,
+        FLEX_WRAPS,
+        0,
+        "flexWrap"
+      );
+      records[offset + 25] = enumCode(
+        style.justifyContent,
+        JUSTIFY_CONTENT,
+        0,
+        "justifyContent"
+      );
+      records[offset + 26] = enumCode(
+        style.alignItems,
+        ALIGNMENTS,
+        0,
+        "alignItems"
+      );
+      records[offset + 27] = enumCode(
+        style.alignSelf,
+        ALIGN_SELF,
+        0,
+        "alignSelf"
+      );
+      records[offset + 50] = enumCode(style.alignContent, ALIGN_CONTENT, 0, "alignContent");
+      records[offset + 51] = enumCode(style.position, POSITIONS, 0, "position");
+      records[offset + 52] = enumCode(style.boxSizing, BOX_SIZINGS, 0, "boxSizing");
+      numeric(records, offset + 53, style.aspectRatio, 0, "aspectRatio");
+      if (records[offset + 53] < 0 || records[offset + 53] !== 0 && records[offset + 53] <= 0)
+        throw new TypeError("Standalone layout aspectRatio must be positive.");
+      length(records, offset + 54, style.left, "left");
+      length(records, offset + 56, style.right, "right");
+      length(records, offset + 58, style.top, "top");
+      length(records, offset + 60, style.bottom, "bottom");
+      const borderLeft = edge(style, "left", "borderWidth") ?? 0;
+      const borderRight = edge(style, "right", "borderWidth") ?? 0;
+      const borderTop = edge(style, "top", "borderWidth") ?? 0;
+      const borderBottom = edge(style, "bottom", "borderWidth") ?? 0;
+      records[offset + 62] = finite(borderLeft, "borderWidth.left");
+      records[offset + 63] = finite(borderRight, "borderWidth.right");
+      records[offset + 64] = finite(borderTop, "borderWidth.top");
+      records[offset + 65] = finite(borderBottom, "borderWidth.bottom");
+      if (records[offset + 62] < 0 || records[offset + 63] < 0 || records[offset + 64] < 0 || records[offset + 65] < 0)
+        throw new TypeError("Standalone layout borderWidth must be nonnegative.");
+      length(
+        records,
+        offset + 28,
+        style.marginLeft ?? style.margin,
+        "marginLeft"
+      );
+      length(
+        records,
+        offset + 30,
+        style.marginRight ?? style.margin,
+        "marginRight"
+      );
+      length(
+        records,
+        offset + 32,
+        style.marginTop ?? style.margin,
+        "marginTop"
+      );
+      length(
+        records,
+        offset + 34,
+        style.marginBottom ?? style.margin,
+        "marginBottom"
+      );
+      length(
+        records,
+        offset + 36,
+        edge(style, "left", "padding") ?? 0,
+        "padding.left"
+      );
+      length(
+        records,
+        offset + 38,
+        edge(style, "right", "padding") ?? 0,
+        "padding.right"
+      );
+      length(
+        records,
+        offset + 40,
+        edge(style, "top", "padding") ?? 0,
+        "padding.top"
+      );
+      length(
+        records,
+        offset + 42,
+        edge(style, "bottom", "padding") ?? 0,
+        "padding.bottom"
+      );
+      if (records[offset + 37] !== LENGTH_POINT && records[offset + 37] !== LENGTH_PERCENT || records[offset + 39] !== LENGTH_POINT && records[offset + 39] !== LENGTH_PERCENT || records[offset + 41] !== LENGTH_POINT && records[offset + 41] !== LENGTH_PERCENT || records[offset + 43] !== LENGTH_POINT && records[offset + 43] !== LENGTH_PERCENT)
+        throw new TypeError(
+          "Standalone layout padding must be numeric or percentage."
+        );
+      records[offset + 44] = node.measure ? 1 : 0;
+      records[offset + 49] = node.measureIntrinsic ? 1 : 0;
+      records[offset + 45] = numericValue(
+        style.gridColumnStart,
+        0,
+        "gridColumnStart"
+      );
+      records[offset + 46] = numericValue(
+        style.gridColumnSpan,
+        1,
+        "gridColumnSpan"
+      );
+      records[offset + 47] = numericValue(
+        style.gridRowStart,
+        0,
+        "gridRowStart"
+      );
+      records[offset + 48] = numericValue(style.gridRowSpan, 1, "gridRowSpan");
+    }
+    const grid = [];
+    const breadth = (value, property) => {
+      if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        return [0, value];
+      if (typeof value === "string" && /^(?:\d+|\d*\.\d+)%$/.test(value))
+        return [1, Number.parseFloat(value)];
+      if (typeof value === "string" && /^(?:\d+|\d*\.\d+)fr$/.test(value) && Number.parseFloat(value) >= 0)
+        return [2, Number.parseFloat(value)];
+      if (value === "min-content") return [3, 0];
+      if (value === "max-content") return [4, 0];
+      if (value === "auto") return [5, 0];
+      throw new TypeError(
+        `Standalone Grid ${property} must be a finite, percentage, fractional, or intrinsic track.`
+      );
+    };
+    const track = (value, property) => {
+      if (value !== null && typeof value === "object" && value.kind === "minmax") {
+        const min = breadth(
+          value.min,
+          `${property}.min`
+        );
+        const max = breadth(
+          value.max,
+          `${property}.max`
+        );
+        return [6, 0, min[0], min[1], max[0], max[1], 0];
+      }
+      if (value !== null && typeof value === "object" && value.kind === "fit-content") {
+        const limit = breadth(
+          value.limit,
+          `${property}.limit`
+        );
+        if (limit[0] > 1)
+          throw new TypeError(
+            `Standalone Grid ${property} fit-content limit must be numeric or percentage.`
+          );
+        return [limit[0] === 1 ? 9 : 7, limit[1], 0, 0, 4, 0, 0];
+      }
+      const fixed = breadth(value, property);
+      return [fixed[0], fixed[1], 0, 0, 4, fixed[1], 0];
+    };
+    const expand = (value, property, target, nestedAuto = false) => {
+      if (value !== null && typeof value === "object" && value.kind === "repeat") {
+        const repeat = value;
+        if (!Array.isArray(repeat.tracks) || !repeat.tracks.length)
+          throw new TypeError(
+            `Standalone Grid ${property} repeat requires tracks.`
+          );
+        if (repeat.count === "auto-fill" || repeat.count === "auto-fit") {
+          if (nestedAuto)
+            throw new TypeError(
+              `Standalone Grid ${property} does not permit nested automatic repeats.`
+            );
+          const pattern = [];
+          for (const nested of repeat.tracks)
+            expand(nested, `${property}.tracks`, pattern, true);
+          target.push([
+            8,
+            repeat.count === "auto-fill" ? 1 : 2,
+            pattern.length,
+            0,
+            0,
+            0,
+            0
+          ]);
+          for (const record of pattern) target.push(record);
+          return;
+        }
+        if (!Number.isInteger(repeat.count) || repeat.count < 1)
+          throw new TypeError(
+            `Standalone Grid ${property} repeat count must be positive or automatic.`
+          );
+        for (let count2 = 0; count2 < repeat.count; count2++)
+          for (const nested of repeat.tracks)
+            expand(nested, `${property}.tracks`, target, nestedAuto);
+        return;
+      }
+      target.push(track(value, property));
+    };
+    for (let index = 0; index < nodes.length; index++) {
+      const style = nodes[index].style;
+      if (style.layout !== "grid") continue;
+      const columns = style.gridTemplateColumns;
+      const rows = style.gridTemplateRows;
+      if (!Array.isArray(columns) || !Array.isArray(rows) || !columns.length || !rows.length)
+        throw new TypeError(
+          "Standalone Grid requires nonempty explicit column and row tracks."
+        );
+      const packedColumns = [];
+      const packedRows = [];
+      for (const value of columns)
+        expand(value, "gridTemplateColumns", packedColumns);
+      for (const value of rows) expand(value, "gridTemplateRows", packedRows);
+      const flow = enumCode(style.gridAutoFlow, GRID_FLOWS, 0, "gridAutoFlow");
+      const autoColumn = style.gridAutoColumns === void 0 ? void 0 : track(style.gridAutoColumns, "gridAutoColumns");
+      const autoRow = style.gridAutoRows === void 0 ? void 0 : track(style.gridAutoRows, "gridAutoRows");
+      grid.push(
+        index,
+        packedColumns.length,
+        packedRows.length,
+        numericValue(style.columnGap ?? style.gap, 0, "columnGap"),
+        numericValue(style.rowGap ?? style.gap, 0, "rowGap"),
+        flow,
+        autoColumn ? 1 : 0,
+        autoRow ? 1 : 0,
+        ...autoColumn ?? [0, 0, 0, 0, 4, 0, 0],
+        ...autoRow ?? [0, 0, 0, 0, 4, 0, 0]
+      );
+      for (const value of packedColumns) grid.push(...value);
+      for (const value of packedRows) grid.push(...value);
+    }
+    const gridPointer = this.kernel.standalone_tree_resize_grid(
+      this.#handle,
+      this.#generation,
+      grid.length
+    );
+    if (!gridPointer && grid.length)
+      throw new Error("Standalone native Grid storage allocation failed.");
+    new Float64Array(this.kernel.memory.buffer, gridPointer, grid.length).set(
+      grid
+    );
+    const childPointer = this.kernel.standalone_tree_resize_children(
+      this.#handle,
+      this.#generation,
+      children.length
+    );
+    if (!childPointer && children.length)
+      throw new Error("Standalone native child storage allocation failed.");
+    new Uint32Array(
+      this.kernel.memory.buffer,
+      childPointer,
+      children.length
+    ).set(children);
+    status(
+      this.kernel.standalone_tree_replace(
+        this.#handle,
+        this.#generation,
+        rootIndex,
+        input.direction === "rtl" ? 1 : 0
+      ),
+      "tree replacement"
+    );
+    status(
+      this.kernel.standalone_tree_prepare(
+        this.#handle,
+        this.#generation,
+        input.width,
+        input.height
+      ),
+      "measurement preparation"
+    );
+    const count = this.kernel.standalone_tree_measure_count(
+      this.#handle,
+      this.#generation
+    );
+    const measurementPointer = this.kernel.standalone_tree_resize_measurements(
+      this.#handle,
+      this.#generation,
+      count
+    );
+    if (!measurementPointer && count)
+      throw new Error(
+        "Standalone native measurement storage allocation failed."
+      );
+    const measurements = new Float64Array(
+      this.kernel.memory.buffer,
+      measurementPointer,
+      count * MEASUREMENT_STRIDE
+    );
+    for (let index = 0; index < count; index++) {
+      const nativeId = this.kernel.standalone_tree_measure_node(
+        this.#handle,
+        this.#generation,
+        index
+      );
+      const node = nodes[nativeId];
+      const kind = this.kernel.standalone_tree_measure_kind(
+        this.#handle,
+        this.#generation,
+        index
+      );
+      if (!node)
+        throw new Error(
+          "Standalone native tree requested an unknown measurement node."
+        );
+      const offset = index * MEASUREMENT_STRIDE;
+      measurements[offset] = nativeId;
+      if (kind === 0) {
+        if (!node.measure)
+          throw new Error(
+            "Standalone native tree requested a node without an owned measurement callback."
+          );
+        const result = node.measure({
+          width: {
+            minimum: this.kernel.standalone_tree_measure_width_min(
+              this.#handle,
+              this.#generation,
+              index
+            ),
+            maximum: this.kernel.standalone_tree_measure_width_max(
+              this.#handle,
+              this.#generation,
+              index
+            )
+          },
+          height: {
+            minimum: this.kernel.standalone_tree_measure_height_min(
+              this.#handle,
+              this.#generation,
+              index
+            ),
+            maximum: this.kernel.standalone_tree_measure_height_max(
+              this.#handle,
+              this.#generation,
+              index
+            )
+          }
+        });
+        measurements[offset + 1] = finite(result.width, "measurement width");
+        measurements[offset + 2] = finite(result.height, "measurement height");
+      } else if (kind === 1) {
+        if (!node.measureIntrinsic)
+          throw new Error(
+            "Standalone native tree requested a node without an owned intrinsic measurement callback."
+          );
+        const result = node.measureIntrinsic();
+        measurements[offset + 3] = finite(
+          result.minWidth,
+          "intrinsic minimum width"
+        );
+        measurements[offset + 4] = finite(
+          result.maxWidth,
+          "intrinsic maximum width"
+        );
+        measurements[offset + 5] = finite(
+          result.minHeight,
+          "intrinsic minimum height"
+        );
+        measurements[offset + 6] = finite(
+          result.maxHeight,
+          "intrinsic maximum height"
+        );
+        if (measurements[offset + 3] > measurements[offset + 4] || measurements[offset + 5] > measurements[offset + 6])
+          throw new RangeError(
+            "Standalone intrinsic measurement minimums must not exceed maximums."
+          );
+      } else
+        throw new Error(
+          "Standalone native tree requested an unknown measurement kind."
+        );
+    }
+    status(
+      this.kernel.standalone_tree_solve(
+        this.#handle,
+        this.#generation,
+        input.width,
+        input.height
+      ),
+      "solve"
+    );
+    let settled = false;
+    for (let phase = 0; phase <= nodes.length; phase++) {
+      status(
+        this.kernel.standalone_tree_prepare_settled_measurements(
+          this.#handle,
+          this.#generation
+        ),
+        "settled measurement preparation"
+      );
+      const settledCount = this.kernel.standalone_tree_measure_count(
+        this.#handle,
+        this.#generation
+      );
+      if (!settledCount) {
+        settled = true;
+        break;
+      }
+      {
+        const settledPointer = this.kernel.standalone_tree_resize_measurements(this.#handle, this.#generation, settledCount);
+        if (!settledPointer) throw new Error("Standalone native settled measurement storage allocation failed.");
+        const settled2 = new Float64Array(this.kernel.memory.buffer, settledPointer, settledCount * MEASUREMENT_STRIDE);
+        for (let index = 0; index < settledCount; index++) {
+          const nativeId = this.kernel.standalone_tree_measure_node(this.#handle, this.#generation, index);
+          const node = nodes[nativeId];
+          const kind = this.kernel.standalone_tree_measure_kind(this.#handle, this.#generation, index);
+          if (!node) throw new Error("Standalone native tree requested an unknown settled measurement node.");
+          const offset = index * MEASUREMENT_STRIDE;
+          settled2[offset] = nativeId;
+          if (kind === 0) {
+            if (!node.measure) throw new Error("Standalone native tree requested a node without an owned measurement callback.");
+            const result = node.measure({ width: { minimum: this.kernel.standalone_tree_measure_width_min(this.#handle, this.#generation, index), maximum: this.kernel.standalone_tree_measure_width_max(this.#handle, this.#generation, index) }, height: { minimum: this.kernel.standalone_tree_measure_height_min(this.#handle, this.#generation, index), maximum: this.kernel.standalone_tree_measure_height_max(this.#handle, this.#generation, index) } });
+            settled2[offset + 1] = finite(result.width, "settled measurement width");
+            settled2[offset + 2] = finite(result.height, "settled measurement height");
+          } else if (kind === 1) {
+            if (!node.measureIntrinsic) throw new Error("Standalone native tree requested a node without an owned intrinsic measurement callback.");
+            const result = node.measureIntrinsic();
+            settled2[offset + 3] = finite(result.minWidth, "settled intrinsic minimum width");
+            settled2[offset + 4] = finite(result.maxWidth, "settled intrinsic maximum width");
+            settled2[offset + 5] = finite(result.minHeight, "settled intrinsic minimum height");
+            settled2[offset + 6] = finite(result.maxHeight, "settled intrinsic maximum height");
+            if (settled2[offset + 3] > settled2[offset + 4] || settled2[offset + 5] > settled2[offset + 6]) throw new RangeError("Standalone settled intrinsic measurement minimums must not exceed maximums.");
+          } else throw new Error("Standalone native tree requested an unknown settled measurement kind.");
+        }
+        status(this.kernel.standalone_tree_solve(this.#handle, this.#generation, input.width, input.height), "settled solve");
+      }
+    }
+    if (!settled)
+      throw new Error(`Standalone native layout measurement continuation did not converge within ${nodes.length + 1} native dependency phases.`);
+    const boxCount = this.kernel.standalone_tree_box_count(
+      this.#handle,
+      this.#generation
+    );
+    if (boxCount !== nodes.length)
+      throw new Error("Standalone native tree returned an incomplete box set.");
+    const boxes = [];
+    for (let index = 0; index < boxCount; index++) {
+      const nativeId = this.kernel.standalone_tree_box_id(
+        this.#handle,
+        this.#generation,
+        index
+      );
+      const source = nodes[nativeId];
+      if (!source)
+        throw new Error("Standalone native tree returned an unknown node id.");
+      const box = {
+        id: source.id,
+        x: this.kernel.standalone_tree_box_x(
+          this.#handle,
+          this.#generation,
+          index
+        ),
+        y: this.kernel.standalone_tree_box_y(
+          this.#handle,
+          this.#generation,
+          index
+        ),
+        width: this.kernel.standalone_tree_box_width(
+          this.#handle,
+          this.#generation,
+          index
+        ),
+        height: this.kernel.standalone_tree_box_height(
+          this.#handle,
+          this.#generation,
+          index
+        )
+      };
+      boxes.push(box);
+    }
+    return Object.freeze(
+      boxes.map((box) => Object.freeze(box))
+    );
+  }
+  dispose() {
+    const kernel = this.#kernel;
+    if (!kernel) return;
+    this.#kernel = void 0;
+    try {
+      if (this.#handle && kernel.standalone_tree_dispose(this.#handle, this.#generation) !== 0)
+        throw new Error("Standalone native tree disposal failed.");
+    } finally {
+      this.#handle = 0;
+      this.#generation = 0;
+      kernel.dispose();
+    }
+  }
+}
+function createStandaloneLayoutKernel() {
+  return new NativeStandaloneLayoutKernel();
+}
+export {
+  createStandaloneLayoutKernel
+};
+//# sourceMappingURL=standalone-kernel.js.map