@web-ts-toolkit/json-frame 0.34.3 → 0.35.0

package/index.mjs

@@ -0,0 +1,1645 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/errors.ts
+var freezeCopy = (values) => Object.freeze([...values]);
+var JsonFrameError = class extends Error {
+  constructor(message, context = {}) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = "JsonFrameError";
+    this.orient = context.orient;
+    this.path = context.path;
+    this.row = context.row;
+    this.column = context.column;
+    this.value = context.value;
+  }
+};
+var JsonFrameParseError = class extends JsonFrameError {
+  constructor(message, cause) {
+    super(message);
+    this.name = "JsonFrameParseError";
+    this.cause = cause;
+  }
+};
+var JsonFrameOptionError = class extends JsonFrameError {
+  constructor(message, option, value) {
+    super(message, { value });
+    this.name = "JsonFrameOptionError";
+    this.option = option;
+  }
+};
+var JsonFrameValidationError = class extends JsonFrameError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "JsonFrameValidationError";
+    this.orient = context.orient;
+  }
+};
+var AmbiguousOrientError = class extends JsonFrameError {
+  constructor(message, candidates) {
+    super(message);
+    this.name = "AmbiguousOrientError";
+    this.candidates = freezeCopy(candidates);
+  }
+};
+var UnsupportedFeatureError = class extends JsonFrameError {
+  constructor(message, feature, context = {}) {
+    super(message, context);
+    this.name = "UnsupportedFeatureError";
+    this.feature = feature;
+    this.orient = context.orient;
+  }
+};
+var ExportKeyCollisionError = class extends JsonFrameError {
+  constructor(message, orient, key, labels) {
+    super(message, { orient });
+    this.name = "ExportKeyCollisionError";
+    this.orient = orient;
+    this.key = key;
+    this.labels = freezeCopy(labels);
+  }
+};
+
+// src/export/payload.ts
+var createRecord = () => /* @__PURE__ */ Object.create(null);
+var cloneJsonValue = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneJsonValue(entry));
+  }
+  if (value !== null && typeof value === "object") {
+    const cloned = createRecord();
+    for (const [key, entryValue] of Object.entries(value)) {
+      cloned[key] = cloneJsonValue(entryValue);
+    }
+    return cloned;
+  }
+  return value;
+};
+var cloneSchemaField = (field, name = field.name) => {
+  const cloned = createRecord();
+  for (const [key, value] of Object.entries(field)) {
+    cloned[key] = key === "name" ? name : value === void 0 ? void 0 : cloneJsonValue(value);
+  }
+  return cloned;
+};
+var cloneSchema = (schema, fields, primaryKey) => {
+  const cloned = createRecord();
+  if (schema !== void 0) {
+    for (const [key, value] of Object.entries(schema)) {
+      if (key === "fields" || key === "primaryKey") {
+        continue;
+      }
+      cloned[key] = value === void 0 ? void 0 : cloneJsonValue(value);
+    }
+  }
+  cloned.fields = fields.map((field) => cloneSchemaField(field));
+  if (primaryKey !== void 0) {
+    cloned.primaryKey = [...primaryKey];
+  }
+  return cloned;
+};
+var mapColumnTypeToSchemaField = (name, info) => {
+  const type = (() => {
+    switch (info.type) {
+      case "integer":
+        return "integer";
+      case "float":
+        return "number";
+      case "string":
+      case "categorical":
+        return "string";
+      case "boolean":
+        return "boolean";
+      case "datetime":
+        return "datetime";
+      case "mixed":
+      case "unknown":
+        return "any";
+      default: {
+        const exhaustive = info.type;
+        throw new JsonFrameValidationError("Unsupported logical column type for table export.", {
+          path: "$.columnInfo",
+          column: name,
+          value: exhaustive
+        });
+      }
+    }
+  })();
+  return info.type === "categorical" ? { name, type, extDtype: "category" } : { name, type };
+};
+var inferIndexFieldType = (index) => {
+  let sawString = false;
+  let sawInteger = false;
+  let sawFloat = false;
+  for (const label of index) {
+    if (typeof label === "string") {
+      sawString = true;
+      continue;
+    }
+    if (Number.isInteger(label)) {
+      sawInteger = true;
+      continue;
+    }
+    sawFloat = true;
+  }
+  if (sawString && (sawInteger || sawFloat)) {
+    return "any";
+  }
+  if (sawString) {
+    return "string";
+  }
+  if (sawFloat) {
+    return "number";
+  }
+  if (sawInteger) {
+    return "integer";
+  }
+  return "string";
+};
+var getIndexFieldTemplate = (state) => {
+  if (state.tableSchema === void 0 || state.tableIndexField === void 0) {
+    return void 0;
+  }
+  if (state.tableSchema.fields.length === state.columns.length + 1) {
+    return state.tableSchema.fields[0];
+  }
+  return state.tableSchema.fields.find((field) => field.name === state.tableIndexField);
+};
+var getDataFieldTemplates = (state) => {
+  if (state.tableSchema === void 0) {
+    return [];
+  }
+  if (state.tableIndexField === void 0) {
+    return state.tableSchema.fields.slice(0, state.columns.length);
+  }
+  if (state.tableSchema.fields.length >= state.columns.length + 1) {
+    return state.tableSchema.fields.slice(1, state.columns.length + 1);
+  }
+  let skippedIndexField = false;
+  const templates = [];
+  for (const field of state.tableSchema.fields) {
+    if (!skippedIndexField && field.name === state.tableIndexField) {
+      skippedIndexField = true;
+      continue;
+    }
+    templates.push(field);
+    if (templates.length === state.columns.length) {
+      break;
+    }
+  }
+  return templates;
+};
+var resolveIndexFieldName = (state, options) => {
+  if (options !== void 0 && (Array.isArray(options) || typeof options !== "object" || options === null)) {
+    throw new JsonFrameOptionError("`toTable` options must be an object when provided.", "options", options);
+  }
+  if (options?.indexField !== void 0 && typeof options.indexField !== "string") {
+    throw new JsonFrameOptionError(
+      "`toTable` options.indexField must be a string when provided.",
+      "indexField",
+      options.indexField
+    );
+  }
+  if (state.indexKind === "synthetic") {
+    return void 0;
+  }
+  const indexField = options?.indexField ?? state.tableIndexField ?? "index";
+  if (state.columns.includes(indexField)) {
+    throw new JsonFrameValidationError("Table export index field name must not collide with a data column.", {
+      path: "$.schema.fields",
+      column: indexField,
+      value: indexField
+    });
+  }
+  return indexField;
+};
+var resolveIndexKeys = (state, orient) => {
+  const seenKeys = /* @__PURE__ */ new Map();
+  const keys = [];
+  for (const label of state.index) {
+    const key = String(label);
+    const priorLabel = seenKeys.get(key);
+    if (priorLabel !== void 0) {
+      throw new ExportKeyCollisionError(
+        `Cannot export distinct rows to orient="${orient}" because index labels collide after stringification.`,
+        orient,
+        key,
+        [priorLabel, label]
+      );
+    }
+    seenKeys.set(key, label);
+    keys.push(key);
+  }
+  return keys;
+};
+var exportRecords = (state, materialized) => {
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < state.index.length; rowIndex += 1) {
+    const row = createRecord();
+    for (const column of state.columns) {
+      row[column] = materialized.get(column)[rowIndex];
+    }
+    rows.push(row);
+  }
+  return rows;
+};
+var exportIndex = (state, materialized) => {
+  const keys = resolveIndexKeys(state, "index");
+  const rows = createRecord();
+  for (let rowIndex = 0; rowIndex < state.index.length; rowIndex += 1) {
+    const row = createRecord();
+    for (const column of state.columns) {
+      row[column] = materialized.get(column)[rowIndex];
+    }
+    rows[keys[rowIndex]] = row;
+  }
+  return rows;
+};
+var exportColumns = (state, materialized) => {
+  const keys = resolveIndexKeys(state, "columns");
+  const columns = createRecord();
+  for (const column of state.columns) {
+    const values = createRecord();
+    const entries = materialized.get(column);
+    for (let rowIndex = 0; rowIndex < state.index.length; rowIndex += 1) {
+      values[keys[rowIndex]] = entries[rowIndex];
+    }
+    columns[column] = values;
+  }
+  return columns;
+};
+var exportValues = (state, materialized) => {
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < state.index.length; rowIndex += 1) {
+    rows.push(state.columns.map((column) => materialized.get(column)[rowIndex]));
+  }
+  return rows;
+};
+var exportSplit = (state, materialized) => ({
+  columns: [...state.columns],
+  index: [...state.index],
+  data: exportValues(state, materialized)
+});
+var exportTable = (state, materialized, columnInfo, options) => {
+  const indexField = resolveIndexFieldName(state, options);
+  const indexTemplate = getIndexFieldTemplate(state);
+  const dataTemplates = getDataFieldTemplates(state);
+  const fields = [];
+  if (indexField !== void 0) {
+    fields.push(
+      indexTemplate === void 0 ? { name: indexField, type: inferIndexFieldType(state.index) } : cloneSchemaField(indexTemplate, indexField)
+    );
+  }
+  for (let columnIndex = 0; columnIndex < state.columns.length; columnIndex += 1) {
+    const column = state.columns[columnIndex];
+    const template = dataTemplates[columnIndex];
+    fields.push(
+      template === void 0 ? mapColumnTypeToSchemaField(column, columnInfo.get(column)) : cloneSchemaField(template, column)
+    );
+  }
+  const data = [];
+  for (let rowIndex = 0; rowIndex < state.index.length; rowIndex += 1) {
+    const row = createRecord();
+    if (indexField !== void 0) {
+      row[indexField] = state.index[rowIndex];
+    }
+    for (const column of state.columns) {
+      row[column] = materialized.get(column)[rowIndex];
+    }
+    data.push(row);
+  }
+  return {
+    schema: cloneSchema(state.tableSchema, fields, indexField === void 0 ? void 0 : [indexField]),
+    data
+  };
+};
+
+// src/frame/column.ts
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+var freezeArray = (values) => Object.freeze([...values]);
+var freezeColumnInfo = (info) => Object.freeze({ ...info });
+var hasCategoricalMetadata = (field) => field.constraints?.enum !== void 0 || field.ordered === true || field.extDtype === "category";
+var mapTableSchemaFieldType = (field) => {
+  if (hasCategoricalMetadata(field)) {
+    return "categorical";
+  }
+  switch (field.type) {
+    case "boolean":
+      return "boolean";
+    case "integer":
+    case "year":
+      return "integer";
+    case "number":
+      return "float";
+    case "date":
+    case "datetime":
+      return "datetime";
+    case "string":
+      return "string";
+    case "any":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+};
+var inferColumnType = (values) => {
+  let nullable = false;
+  let sawBoolean = false;
+  let sawString = false;
+  let sawInteger = false;
+  let sawFloat = false;
+  let sawStructured = false;
+  for (const value of values) {
+    if (value === null) {
+      nullable = true;
+      continue;
+    }
+    if (typeof value === "boolean") {
+      sawBoolean = true;
+      continue;
+    }
+    if (typeof value === "string") {
+      sawString = true;
+      continue;
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        sawInteger = true;
+      } else {
+        sawFloat = true;
+      }
+      continue;
+    }
+    sawStructured = true;
+  }
+  const nonNullKinds = [sawBoolean, sawString, sawInteger || sawFloat, sawStructured].filter(Boolean).length;
+  if (nonNullKinds === 0) {
+    return freezeColumnInfo({ type: "unknown", nullable });
+  }
+  if (sawStructured || nonNullKinds > 1 || sawBoolean && (sawString || sawInteger || sawFloat)) {
+    return freezeColumnInfo({ type: "mixed", nullable });
+  }
+  if (sawString) {
+    return freezeColumnInfo({ type: "string", nullable });
+  }
+  if (sawBoolean) {
+    return freezeColumnInfo({ type: "boolean", nullable });
+  }
+  if (sawFloat) {
+    return freezeColumnInfo({ type: "float", nullable });
+  }
+  return freezeColumnInfo({ type: "integer", nullable });
+};
+var packColumn = (values, info, packThreshold) => {
+  if (packThreshold === 0 || values.length < packThreshold || info.nullable) {
+    return freezeArray(values);
+  }
+  if (info.type === "integer") {
+    const packed = new Int32Array(values.length);
+    for (let index = 0; index < values.length; index += 1) {
+      const value = values[index];
+      if (typeof value !== "number" || !Number.isInteger(value) || value < INT32_MIN || value > INT32_MAX) {
+        return freezeArray(values);
+      }
+      packed[index] = value;
+    }
+    return packed;
+  }
+  if (info.type === "float") {
+    const packed = new Float64Array(values.length);
+    for (let index = 0; index < values.length; index += 1) {
+      const value = values[index];
+      if (typeof value !== "number") {
+        return freezeArray(values);
+      }
+      packed[index] = value;
+    }
+    return packed;
+  }
+  return freezeArray(values);
+};
+var validateExplicitColumnTypes = (columns, columnTypes) => {
+  if (columnTypes === void 0) {
+    return;
+  }
+  const knownColumns = new Set(columns);
+  for (const column of Object.keys(columnTypes)) {
+    if (!knownColumns.has(column)) {
+      throw new JsonFrameOptionError(
+        "`options.columnTypes` keys must match parsed column names.",
+        `columnTypes.${column}`,
+        columnTypes[column]
+      );
+    }
+  }
+};
+var resolveSchemaTypeByColumn = (frame) => {
+  if (frame.tableSchema === void 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const schemaTypes = /* @__PURE__ */ new Map();
+  for (const field of frame.tableSchema.fields) {
+    if (frame.columns.includes(field.name)) {
+      schemaTypes.set(field.name, mapTableSchemaFieldType(field));
+    }
+  }
+  return schemaTypes;
+};
+var materializeColumn = (column) => Array.isArray(column) ? freezeArray(column) : freezeArray(Array.from(column));
+var materializeFrameData = (columns, data) => {
+  const materialized = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    const stored = data.get(column);
+    if (stored === void 0) {
+      throw new JsonFrameValidationError("Stored frame data is missing a declared column.", {
+        path: "$",
+        column
+      });
+    }
+    materialized.set(column, materializeColumn(stored));
+  }
+  return materialized;
+};
+var buildFrameState = (frame, options) => {
+  validateExplicitColumnTypes(frame.columns, options.columnTypes);
+  const schemaTypes = resolveSchemaTypeByColumn(frame);
+  const data = /* @__PURE__ */ new Map();
+  const columnInfo = /* @__PURE__ */ new Map();
+  for (const column of frame.columns) {
+    const values = frame.data.get(column);
+    if (values === void 0) {
+      throw new JsonFrameValidationError("Parsed frame data is missing a declared column.", {
+        orient: frame.orient,
+        column
+      });
+    }
+    const inferred = inferColumnType(values);
+    const resolvedType = schemaTypes.get(column) ?? options.columnTypes?.[column] ?? inferred.type;
+    const info = freezeColumnInfo({ type: resolvedType, nullable: inferred.nullable });
+    columnInfo.set(column, info);
+    data.set(column, packColumn(values, info, options.packThreshold));
+  }
+  return {
+    columns: freezeArray(frame.columns),
+    index: freezeArray(frame.index),
+    indexKind: frame.indexKind,
+    data,
+    columnInfo,
+    ...frame.tableSchema === void 0 ? {} : { tableSchema: frame.tableSchema },
+    ...frame.tableIndexField === void 0 ? {} : { tableIndexField: frame.tableIndexField }
+  };
+};
+var createFrameStateFromData = (frame, options) => buildFrameState(frame, options);
+var createFrameState = (frame, options) => buildFrameState(frame, options);
+
+// src/frame/DataFrame.ts
+var hasOwn = Object.prototype.hasOwnProperty;
+var frameStateByInstance = /* @__PURE__ */ new WeakMap();
+var freezeArray2 = (values) => Object.freeze([...values]);
+var cloneField = (field, name = field.name) => Object.freeze({ ...field, name });
+var cloneSchema2 = (schema, fields, primaryKey) => {
+  const cloned = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "fields" || key === "primaryKey") {
+      continue;
+    }
+    cloned[key] = value;
+  }
+  cloned.fields = freezeArray2(fields);
+  if (primaryKey !== void 0) {
+    cloned.primaryKey = freezeArray2(primaryKey);
+  }
+  return Object.freeze(cloned);
+};
+var _state, _packThreshold, _DataFrame_instances, assertRowPosition_fn, materializedData_fn, createRow_fn, columnTypeOverrides_fn, rebuild_fn, selectSchema_fn, renameSchema_fn, resetIndexSchema_fn;
+var DataFrame = class {
+  constructor(state, packThreshold) {
+    __privateAdd(this, _DataFrame_instances);
+    __privateAdd(this, _state);
+    __privateAdd(this, _packThreshold);
+    __privateSet(this, _state, state);
+    __privateSet(this, _packThreshold, packThreshold);
+    frameStateByInstance.set(this, state);
+  }
+  get columns() {
+    return freezeArray2(__privateGet(this, _state).columns);
+  }
+  get index() {
+    return freezeArray2(__privateGet(this, _state).index);
+  }
+  get columnInfo() {
+    return new Map(__privateGet(this, _state).columnInfo);
+  }
+  get length() {
+    return __privateGet(this, _state).index.length;
+  }
+  toRecords() {
+    return exportRecords(__privateGet(this, _state), __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this));
+  }
+  toIndex() {
+    return exportIndex(__privateGet(this, _state), __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this));
+  }
+  toColumns() {
+    return exportColumns(__privateGet(this, _state), __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this));
+  }
+  toValues() {
+    return exportValues(__privateGet(this, _state), __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this));
+  }
+  toSplit() {
+    return exportSplit(__privateGet(this, _state), __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this));
+  }
+  toTable(options) {
+    return exportTable(__privateGet(this, _state), __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this), __privateGet(this, _state).columnInfo, options);
+  }
+  toJSONString(orient, options) {
+    switch (orient) {
+      case "records":
+        return JSON.stringify(this.toRecords());
+      case "index":
+        return JSON.stringify(this.toIndex());
+      case "columns":
+        return JSON.stringify(this.toColumns());
+      case "values":
+        return JSON.stringify(this.toValues());
+      case "split":
+        return JSON.stringify(this.toSplit());
+      case "table":
+        return JSON.stringify(this.toTable(options));
+      default: {
+        const exhaustive = orient;
+        throw new JsonFrameValidationError("Unsupported export orient.", { value: exhaustive });
+      }
+    }
+  }
+  row(position) {
+    __privateMethod(this, _DataFrame_instances, assertRowPosition_fn).call(this, position);
+    return __privateMethod(this, _DataFrame_instances, createRow_fn).call(this, __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this), position);
+  }
+  rows() {
+    const materialized = __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this);
+    const rows = __privateGet(this, _state).index.map((_, position) => __privateMethod(this, _DataFrame_instances, createRow_fn).call(this, materialized, position));
+    return freezeArray2(rows);
+  }
+  filter(predicate) {
+    const materialized = __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this);
+    const keptPositions = [];
+    for (let position = 0; position < this.length; position += 1) {
+      if (predicate(__privateMethod(this, _DataFrame_instances, createRow_fn).call(this, materialized, position), __privateGet(this, _state).index[position], position)) {
+        keptPositions.push(position);
+      }
+    }
+    return __privateMethod(this, _DataFrame_instances, rebuild_fn).call(this, {
+      columns: __privateGet(this, _state).columns,
+      sourceColumns: __privateGet(this, _state).columns,
+      positions: keptPositions,
+      index: keptPositions.map((position) => __privateGet(this, _state).index[position]),
+      indexKind: __privateGet(this, _state).indexKind,
+      schema: {
+        tableSchema: __privateGet(this, _state).tableSchema,
+        tableIndexField: __privateGet(this, _state).tableIndexField
+      }
+    });
+  }
+  sort(compare) {
+    const materialized = __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this);
+    const ordering = __privateGet(this, _state).index.map((indexLabel, position) => ({
+      indexLabel,
+      position,
+      row: __privateMethod(this, _DataFrame_instances, createRow_fn).call(this, materialized, position)
+    }));
+    ordering.sort((left, right) => {
+      const result = compare(left.row, right.row, left.indexLabel, right.indexLabel, left.position, right.position);
+      return (Number.isNaN(result) ? 0 : result) || left.position - right.position;
+    });
+    return __privateMethod(this, _DataFrame_instances, rebuild_fn).call(this, {
+      columns: __privateGet(this, _state).columns,
+      sourceColumns: __privateGet(this, _state).columns,
+      positions: ordering.map(({ position }) => position),
+      index: ordering.map(({ indexLabel }) => indexLabel),
+      indexKind: __privateGet(this, _state).indexKind,
+      schema: {
+        tableSchema: __privateGet(this, _state).tableSchema,
+        tableIndexField: __privateGet(this, _state).tableIndexField
+      }
+    });
+  }
+  select(...columns) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const column of columns) {
+      if (!__privateGet(this, _state).data.has(column)) {
+        throw new JsonFrameValidationError("Selected columns must exist in the frame.", {
+          path: "$.columns",
+          column,
+          value: column
+        });
+      }
+      if (seen.has(column)) {
+        throw new JsonFrameValidationError("Selected columns must be unique.", {
+          path: "$.columns",
+          column,
+          value: column
+        });
+      }
+      seen.add(column);
+    }
+    const selectedSchema = __privateMethod(this, _DataFrame_instances, selectSchema_fn).call(this, columns);
+    return __privateMethod(this, _DataFrame_instances, rebuild_fn).call(this, {
+      columns,
+      sourceColumns: columns,
+      positions: __privateGet(this, _state).index.map((_, position) => position),
+      index: __privateGet(this, _state).index,
+      indexKind: __privateGet(this, _state).indexKind,
+      schema: selectedSchema
+    });
+  }
+  rename(mapping) {
+    const nextColumns = __privateGet(this, _state).columns.map((column) => hasOwn.call(mapping, column) ? mapping[column] : column);
+    const seen = /* @__PURE__ */ new Set();
+    for (let position = 0; position < nextColumns.length; position += 1) {
+      const column = nextColumns[position];
+      if (seen.has(column)) {
+        throw new JsonFrameValidationError("Renamed columns must remain unique.", {
+          path: "$.columns",
+          column,
+          value: column
+        });
+      }
+      seen.add(column);
+    }
+    const renamedSchema = __privateMethod(this, _DataFrame_instances, renameSchema_fn).call(this, mapping);
+    return __privateMethod(this, _DataFrame_instances, rebuild_fn).call(this, {
+      columns: nextColumns,
+      sourceColumns: __privateGet(this, _state).columns,
+      positions: __privateGet(this, _state).index.map((_, position) => position),
+      index: __privateGet(this, _state).index,
+      indexKind: __privateGet(this, _state).indexKind,
+      schema: renamedSchema
+    });
+  }
+  resetIndex() {
+    const resetSchema = __privateMethod(this, _DataFrame_instances, resetIndexSchema_fn).call(this);
+    return __privateMethod(this, _DataFrame_instances, rebuild_fn).call(this, {
+      columns: __privateGet(this, _state).columns,
+      sourceColumns: __privateGet(this, _state).columns,
+      positions: __privateGet(this, _state).index.map((_, position) => position),
+      index: __privateGet(this, _state).index.map((_, position) => position),
+      indexKind: "synthetic",
+      schema: resetSchema
+    });
+  }
+};
+_state = new WeakMap();
+_packThreshold = new WeakMap();
+_DataFrame_instances = new WeakSet();
+assertRowPosition_fn = function(position) {
+  if (!Number.isInteger(position) || position < 0 || position >= this.length) {
+    throw new RangeError(`Row position must be an integer in [0, ${this.length}).`);
+  }
+};
+materializedData_fn = function() {
+  return materializeFrameData(__privateGet(this, _state).columns, __privateGet(this, _state).data);
+};
+createRow_fn = function(materialized, position) {
+  const row = /* @__PURE__ */ Object.create(null);
+  for (const column of __privateGet(this, _state).columns) {
+    row[column] = materialized.get(column)[position];
+  }
+  return Object.freeze(row);
+};
+columnTypeOverrides_fn = function(columns, sourceColumns) {
+  return Object.freeze(
+    Object.fromEntries(
+      columns.map((column, position) => [column, __privateGet(this, _state).columnInfo.get(sourceColumns[position]).type])
+    )
+  );
+};
+rebuild_fn = function({
+  columns,
+  sourceColumns,
+  positions,
+  index,
+  indexKind,
+  schema
+}) {
+  const materialized = __privateMethod(this, _DataFrame_instances, materializedData_fn).call(this);
+  const nextData = /* @__PURE__ */ new Map();
+  for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+    const column = columns[columnIndex];
+    const sourceColumn = materialized.get(sourceColumns[columnIndex]);
+    if (sourceColumn === void 0) {
+      throw new JsonFrameValidationError("Stored frame data is missing a declared column.", {
+        path: "$",
+        column
+      });
+    }
+    nextData.set(column, freezeArray2(positions.map((position) => sourceColumn[position])));
+  }
+  const state = createFrameStateFromData(
+    {
+      columns,
+      index,
+      indexKind,
+      data: nextData,
+      ...schema.tableSchema === void 0 ? {} : { tableSchema: schema.tableSchema },
+      ...schema.tableIndexField === void 0 ? {} : { tableIndexField: schema.tableIndexField }
+    },
+    {
+      packThreshold: __privateGet(this, _packThreshold),
+      columnTypes: __privateMethod(this, _DataFrame_instances, columnTypeOverrides_fn).call(this, columns, sourceColumns)
+    }
+  );
+  return createDataFrame(state, __privateGet(this, _packThreshold));
+};
+selectSchema_fn = function(columns) {
+  if (__privateGet(this, _state).tableSchema === void 0) {
+    return {};
+  }
+  const fieldByName = new Map(__privateGet(this, _state).tableSchema.fields.map((field) => [field.name, field]));
+  const fields = [];
+  if (__privateGet(this, _state).tableIndexField !== void 0) {
+    const indexField = fieldByName.get(__privateGet(this, _state).tableIndexField);
+    if (indexField !== void 0) {
+      fields.push(cloneField(indexField));
+    }
+  }
+  for (const column of columns) {
+    const field = fieldByName.get(column);
+    if (field !== void 0) {
+      fields.push(cloneField(field));
+    }
+  }
+  return {
+    tableSchema: cloneSchema2(__privateGet(this, _state).tableSchema, fields, __privateGet(this, _state).tableSchema.primaryKey),
+    ...__privateGet(this, _state).tableIndexField === void 0 ? {} : { tableIndexField: __privateGet(this, _state).tableIndexField }
+  };
+};
+renameSchema_fn = function(mapping) {
+  if (__privateGet(this, _state).tableSchema === void 0) {
+    return {};
+  }
+  const fields = __privateGet(this, _state).tableSchema.fields.map((field) => {
+    if (!__privateGet(this, _state).columns.includes(field.name)) {
+      return cloneField(field);
+    }
+    return cloneField(field, hasOwn.call(mapping, field.name) ? mapping[field.name] : field.name);
+  });
+  return {
+    tableSchema: cloneSchema2(__privateGet(this, _state).tableSchema, fields, __privateGet(this, _state).tableSchema.primaryKey),
+    ...__privateGet(this, _state).tableIndexField === void 0 ? {} : { tableIndexField: __privateGet(this, _state).tableIndexField }
+  };
+};
+resetIndexSchema_fn = function() {
+  if (__privateGet(this, _state).tableSchema === void 0) {
+    return {};
+  }
+  if (__privateGet(this, _state).tableIndexField === void 0) {
+    return {
+      tableSchema: cloneSchema2(
+        __privateGet(this, _state).tableSchema,
+        __privateGet(this, _state).tableSchema.fields.map((field) => cloneField(field))
+      )
+    };
+  }
+  const fields = __privateGet(this, _state).tableSchema.fields.filter((field) => field.name !== __privateGet(this, _state).tableIndexField).map((field) => cloneField(field));
+  return {
+    tableSchema: cloneSchema2(__privateGet(this, _state).tableSchema, fields)
+  };
+};
+var InternalDataFrame = class extends DataFrame {
+  constructor(state, packThreshold) {
+    super(state, packThreshold);
+  }
+};
+var createDataFrame = (state, packThreshold) => new InternalDataFrame(state, packThreshold);
+
+// src/options.ts
+var RESOLVED_ORIENTS = [
+  "records",
+  "index",
+  "columns",
+  "values",
+  "split",
+  "table"
+];
+var ORIENTS = ["auto", ...RESOLVED_ORIENTS];
+var COLUMN_TYPES = [
+  "integer",
+  "float",
+  "string",
+  "boolean",
+  "datetime",
+  "categorical",
+  "mixed",
+  "unknown"
+];
+var DEFAULT_PACK_THRESHOLD = 256;
+var isOrient = (value) => typeof value === "string" && ORIENTS.includes(value);
+var isColumnType = (value) => typeof value === "string" && COLUMN_TYPES.includes(value);
+var normalizeFromOrientOptions = (options) => {
+  if (options == null) {
+    return {
+      orient: "auto",
+      packThreshold: DEFAULT_PACK_THRESHOLD
+    };
+  }
+  if (Array.isArray(options) || typeof options !== "object") {
+    throw new JsonFrameOptionError("`fromOrient` options must be an object when provided.", "options", options);
+  }
+  const orient = options.orient ?? "auto";
+  if (!isOrient(orient)) {
+    throw new JsonFrameOptionError(
+      "`options.orient` must be one of auto, records, index, columns, values, split, or table.",
+      "orient",
+      orient
+    );
+  }
+  const packThreshold = options.packThreshold ?? DEFAULT_PACK_THRESHOLD;
+  if (!Number.isFinite(packThreshold) || !Number.isInteger(packThreshold) || packThreshold < 0) {
+    throw new JsonFrameOptionError(
+      "`options.packThreshold` must be a finite non-negative integer.",
+      "packThreshold",
+      packThreshold
+    );
+  }
+  let columns;
+  if (options.columns !== void 0) {
+    if (!Array.isArray(options.columns)) {
+      throw new JsonFrameOptionError("`options.columns` must be an array of strings.", "columns", options.columns);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    columns = options.columns.map((column) => {
+      if (typeof column !== "string") {
+        throw new JsonFrameOptionError("`options.columns` must contain only strings.", "columns", column);
+      }
+      if (seen.has(column)) {
+        throw new JsonFrameOptionError("`options.columns` must not contain duplicates.", "columns", column);
+      }
+      seen.add(column);
+      return column;
+    });
+  }
+  let columnTypes;
+  if (options.columnTypes !== void 0) {
+    if (Array.isArray(options.columnTypes) || typeof options.columnTypes !== "object" || options.columnTypes === null) {
+      throw new JsonFrameOptionError(
+        "`options.columnTypes` must be an object keyed by column name.",
+        "columnTypes",
+        options.columnTypes
+      );
+    }
+    const entries = Object.entries(options.columnTypes);
+    columnTypes = Object.freeze(
+      Object.fromEntries(
+        entries.map(([column, type]) => {
+          if (!isColumnType(type)) {
+            throw new JsonFrameOptionError(
+              "`options.columnTypes` values must be valid JSON Frame logical column types.",
+              `columnTypes.${column}`,
+              type
+            );
+          }
+          return [column, type];
+        })
+      )
+    );
+  }
+  return {
+    orient,
+    packThreshold,
+    ...columns === void 0 ? {} : { columns: Object.freeze([...columns]) },
+    ...columnTypes === void 0 ? {} : { columnTypes }
+  };
+};
+
+// src/parse/parse.ts
+var hasOwn2 = Object.prototype.hasOwnProperty;
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var freezeArray3 = (values) => Object.freeze([...values]);
+var appendPropertyPath = (path, key) => IDENTIFIER_PATTERN.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+var appendIndexPath = (path, index) => `${path}[${index}]`;
+var isPlainObject = (value) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var assertSupportedIndexLabel = (value, orient, path) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  throw new JsonFrameValidationError("Index labels must be strings or finite numbers.", {
+    orient,
+    path,
+    value
+  });
+};
+var assertUniqueStringColumns = (values, orient, path) => {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    const entryPath = appendIndexPath(path, index);
+    if (typeof value !== "string") {
+      throw new JsonFrameValidationError("Column labels must be strings.", {
+        orient,
+        path: entryPath,
+        value
+      });
+    }
+    if (seen.has(value)) {
+      throw new JsonFrameValidationError("Column labels must be unique.", {
+        orient,
+        path: entryPath,
+        column: value,
+        value
+      });
+    }
+    seen.add(value);
+    columns.push(value);
+  }
+  return freezeArray3(columns);
+};
+var initializeData = (columns) => new Map(columns.map((column) => [column, []]));
+var finalizeFrame = ({
+  orient,
+  columns,
+  index,
+  indexKind,
+  data,
+  tableSchema,
+  tableIndexField
+}) => {
+  const finalizedData = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    const values = data.get(column);
+    if (values === void 0) {
+      throw new JsonFrameValidationError("Parsed frame data is missing a declared column.", {
+        orient,
+        column
+      });
+    }
+    finalizedData.set(column, freezeArray3(values));
+  }
+  return {
+    orient,
+    columns: freezeArray3(columns),
+    index: freezeArray3(index),
+    indexKind,
+    data: finalizedData,
+    ...tableSchema === void 0 ? {} : { tableSchema },
+    ...tableIndexField === void 0 ? {} : { tableIndexField }
+  };
+};
+var validateJsonCompatible = (value, path = "$", stack = /* @__PURE__ */ new Set()) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new JsonFrameValidationError("Numbers must be finite JSON values.", { path, value });
+    }
+    return value;
+  }
+  if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") {
+    throw new JsonFrameValidationError("Input must contain only JSON-compatible values.", { path, value });
+  }
+  if (Array.isArray(value)) {
+    if (stack.has(value)) {
+      throw new JsonFrameValidationError("Input contains a cyclic array.", { path, value });
+    }
+    stack.add(value);
+    const normalized2 = [];
+    for (let index = 0; index < value.length; index += 1) {
+      if (!(index in value)) {
+        stack.delete(value);
+        throw new JsonFrameValidationError("Sparse arrays are not valid JSON input.", {
+          path: appendIndexPath(path, index),
+          value
+        });
+      }
+      normalized2.push(validateJsonCompatible(value[index], appendIndexPath(path, index), stack));
+    }
+    stack.delete(value);
+    return normalized2;
+  }
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("Input objects must be plain JSON objects or arrays.", { path, value });
+  }
+  if (stack.has(value)) {
+    throw new JsonFrameValidationError("Input contains a cyclic object.", { path, value });
+  }
+  stack.add(value);
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [key, entryValue] of Object.entries(value)) {
+    normalized[key] = validateJsonCompatible(entryValue, appendPropertyPath(path, key), stack);
+  }
+  stack.delete(value);
+  return normalized;
+};
+var detectOrient = (value) => {
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      throw new AmbiguousOrientError(
+        "Auto detection cannot distinguish between empty records and empty values payloads.",
+        ["records", "values"]
+      );
+    }
+    if (value.every((entry) => Array.isArray(entry))) {
+      return "values";
+    }
+    if (value.every((entry) => isPlainObject(entry))) {
+      return "records";
+    }
+    throw new JsonFrameValidationError("Auto detection requires a non-empty array of row objects or row arrays.", {
+      path: "$",
+      value
+    });
+  }
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("Auto detection requires a JSON array or object payload.", {
+      path: "$",
+      value
+    });
+  }
+  if (isPlainObject(value.schema) && Array.isArray(value.data)) {
+    return "table";
+  }
+  if (Array.isArray(value.columns) && Array.isArray(value.data) && (value.index === void 0 || Array.isArray(value.index))) {
+    return "split";
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 0 || keys.every((key) => isPlainObject(value[key]))) {
+    throw new AmbiguousOrientError("Auto detection cannot distinguish between index and columns payloads.", [
+      "index",
+      "columns"
+    ]);
+  }
+  throw new JsonFrameValidationError("Auto detection could not resolve the payload orient.", {
+    path: "$",
+    value
+  });
+};
+var parseRecords = (value, orient) => {
+  if (!Array.isArray(value)) {
+    throw new JsonFrameValidationError("`records` payloads must be arrays.", { orient, path: "$", value });
+  }
+  const columns = [];
+  const knownColumns = /* @__PURE__ */ new Set();
+  const data = /* @__PURE__ */ new Map();
+  const index = [];
+  for (let rowIndex = 0; rowIndex < value.length; rowIndex += 1) {
+    const row = value[rowIndex];
+    const rowPath = appendIndexPath("$", rowIndex);
+    if (!isPlainObject(row)) {
+      throw new JsonFrameValidationError("`records` rows must be JSON objects.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        value: row
+      });
+    }
+    for (const column of Object.keys(row)) {
+      if (!knownColumns.has(column)) {
+        knownColumns.add(column);
+        columns.push(column);
+        data.set(column, Array(rowIndex).fill(null));
+      }
+    }
+    for (const column of columns) {
+      data.get(column).push(hasOwn2.call(row, column) ? row[column] : null);
+    }
+    index.push(rowIndex);
+  }
+  return finalizeFrame({
+    orient,
+    columns,
+    index,
+    indexKind: "synthetic",
+    data
+  });
+};
+var parseIndex = (value, orient) => {
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("`index` payloads must be objects keyed by index label.", {
+      orient,
+      path: "$",
+      value
+    });
+  }
+  const columns = [];
+  const knownColumns = /* @__PURE__ */ new Set();
+  const data = /* @__PURE__ */ new Map();
+  const index = Object.keys(value);
+  for (let rowIndex = 0; rowIndex < index.length; rowIndex += 1) {
+    const indexLabel = index[rowIndex];
+    const row = value[indexLabel];
+    const rowPath = appendPropertyPath("$", indexLabel);
+    if (!isPlainObject(row)) {
+      throw new JsonFrameValidationError("`index` payload rows must be JSON objects.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        value: row
+      });
+    }
+    for (const column of Object.keys(row)) {
+      if (!knownColumns.has(column)) {
+        knownColumns.add(column);
+        columns.push(column);
+        data.set(column, Array(rowIndex).fill(null));
+      }
+    }
+    for (const column of columns) {
+      data.get(column).push(hasOwn2.call(row, column) ? row[column] : null);
+    }
+  }
+  return finalizeFrame({
+    orient,
+    columns,
+    index,
+    indexKind: "source",
+    data
+  });
+};
+var parseColumns = (value, orient) => {
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("`columns` payloads must be objects keyed by column label.", {
+      orient,
+      path: "$",
+      value
+    });
+  }
+  const columns = Object.keys(value);
+  const data = /* @__PURE__ */ new Map();
+  if (columns.length === 0) {
+    return finalizeFrame({
+      orient,
+      columns,
+      index: [],
+      indexKind: "source",
+      data
+    });
+  }
+  let index;
+  for (const column of columns) {
+    const columnValue = value[column];
+    const columnPath = appendPropertyPath("$", column);
+    if (!isPlainObject(columnValue)) {
+      throw new JsonFrameValidationError("`columns` payload values must be objects keyed by index label.", {
+        orient,
+        path: columnPath,
+        column,
+        value: columnValue
+      });
+    }
+    const keys = Object.keys(columnValue);
+    if (index === void 0) {
+      index = freezeArray3(keys);
+    } else if (keys.length !== index.length || keys.some((key, indexPosition) => key !== index[indexPosition])) {
+      throw new JsonFrameValidationError("Every `columns` payload column must expose the same ordered index keys.", {
+        orient,
+        path: columnPath,
+        column,
+        value: columnValue
+      });
+    }
+    data.set(
+      column,
+      keys.map((indexKey) => columnValue[indexKey])
+    );
+  }
+  return finalizeFrame({
+    orient,
+    columns,
+    index: index ?? [],
+    indexKind: "source",
+    data
+  });
+};
+var parseValues = (value, options, orient) => {
+  if (options.columns === void 0) {
+    throw new JsonFrameOptionError(
+      '`options.columns` is required for `orient="values"` input.',
+      "columns",
+      options.columns
+    );
+  }
+  if (!Array.isArray(value)) {
+    throw new JsonFrameValidationError("`values` payloads must be arrays of arrays.", { orient, path: "$", value });
+  }
+  const columns = [...options.columns];
+  const data = initializeData(columns);
+  const index = [];
+  for (let rowIndex = 0; rowIndex < value.length; rowIndex += 1) {
+    const row = value[rowIndex];
+    const rowPath = appendIndexPath("$", rowIndex);
+    if (!Array.isArray(row)) {
+      throw new JsonFrameValidationError("`values` rows must be arrays.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        value: row
+      });
+    }
+    if (row.length !== columns.length) {
+      throw new JsonFrameValidationError("`values` row widths must match `options.columns`.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        value: row
+      });
+    }
+    for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+      data.get(columns[columnIndex]).push(row[columnIndex]);
+    }
+    index.push(rowIndex);
+  }
+  return finalizeFrame({
+    orient,
+    columns,
+    index,
+    indexKind: "synthetic",
+    data
+  });
+};
+var parseSplit = (value, orient) => {
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("`split` payloads must be objects.", { orient, path: "$", value });
+  }
+  if (!Array.isArray(value.columns)) {
+    throw new JsonFrameValidationError("`split.columns` must be an array of unique strings.", {
+      orient,
+      path: "$.columns",
+      value: value.columns
+    });
+  }
+  if (!Array.isArray(value.data)) {
+    throw new JsonFrameValidationError("`split.data` must be an array of row arrays.", {
+      orient,
+      path: "$.data",
+      value: value.data
+    });
+  }
+  const columns = assertUniqueStringColumns(value.columns, orient, "$.columns");
+  const data = initializeData(columns);
+  const index = [];
+  const indexKind = Array.isArray(value.index) ? "source" : "synthetic";
+  if (Array.isArray(value.index)) {
+    for (let indexPosition = 0; indexPosition < value.index.length; indexPosition += 1) {
+      index.push(
+        assertSupportedIndexLabel(
+          value.index[indexPosition],
+          orient,
+          appendIndexPath("$.index", indexPosition)
+        )
+      );
+    }
+  }
+  const rows = value.data;
+  if (indexKind === "source" && index.length !== rows.length) {
+    throw new JsonFrameValidationError("`split.index` length must match `split.data` length.", {
+      orient,
+      path: "$.index",
+      value: value.index
+    });
+  }
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+    const row = rows[rowIndex];
+    const rowPath = appendIndexPath("$.data", rowIndex);
+    if (!Array.isArray(row)) {
+      throw new JsonFrameValidationError("`split.data` rows must be arrays.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        value: row
+      });
+    }
+    if (row.length !== columns.length) {
+      throw new JsonFrameValidationError("`split.data` row widths must match `split.columns`.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        value: row
+      });
+    }
+    for (let columnIndex = 0; columnIndex < columns.length; columnIndex += 1) {
+      data.get(columns[columnIndex]).push(row[columnIndex]);
+    }
+    if (indexKind === "synthetic") {
+      index.push(rowIndex);
+    }
+  }
+  return finalizeFrame({
+    orient,
+    columns,
+    index,
+    indexKind,
+    data
+  });
+};
+var cloneConstraints = (value, orient, path) => {
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("Table Schema field constraints must be an object when present.", {
+      orient,
+      path,
+      value
+    });
+  }
+  const cloned = /* @__PURE__ */ Object.create(null);
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key === "enum") {
+      if (!Array.isArray(entryValue)) {
+        throw new JsonFrameValidationError("Table Schema `constraints.enum` must be an array of scalar JSON values.", {
+          orient,
+          path: appendPropertyPath(path, key),
+          value: entryValue
+        });
+      }
+      cloned[key] = freezeArray3(
+        entryValue.map((enumValue, index) => {
+          const enumPath = appendIndexPath(appendPropertyPath(path, key), index);
+          if (enumValue === null || typeof enumValue === "string" || typeof enumValue === "boolean") {
+            return enumValue;
+          }
+          if (typeof enumValue === "number" && Number.isFinite(enumValue)) {
+            return enumValue;
+          }
+          throw new JsonFrameValidationError("Table Schema `constraints.enum` must contain only scalar JSON values.", {
+            orient,
+            path: enumPath,
+            value: enumValue
+          });
+        })
+      );
+      continue;
+    }
+    cloned[key] = entryValue;
+  }
+  return Object.freeze(cloned);
+};
+var cloneTableField = (value, index) => {
+  const orient = "table";
+  const path = appendIndexPath("$.schema.fields", index);
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("Table Schema fields must be objects.", {
+      orient,
+      path,
+      value
+    });
+  }
+  if (typeof value.name !== "string") {
+    throw new JsonFrameValidationError("Table Schema field names must be strings.", {
+      orient,
+      path: appendPropertyPath(path, "name"),
+      value: value.name
+    });
+  }
+  if (typeof value.type !== "string") {
+    throw new JsonFrameValidationError("Table Schema field types must be strings.", {
+      orient,
+      path: appendPropertyPath(path, "type"),
+      value: value.type
+    });
+  }
+  if (value.ordered !== void 0 && typeof value.ordered !== "boolean") {
+    throw new JsonFrameValidationError("Table Schema `ordered` must be boolean when present.", {
+      orient,
+      path: appendPropertyPath(path, "ordered"),
+      value: value.ordered
+    });
+  }
+  const stringKeys = ["format", "extDtype", "tz", "freq"];
+  for (const key of stringKeys) {
+    const entryValue = value[key];
+    if (entryValue !== void 0 && typeof entryValue !== "string") {
+      throw new JsonFrameValidationError(`Table Schema \`${key}\` must be a string when present.`, {
+        orient,
+        path: appendPropertyPath(path, key),
+        value: entryValue
+      });
+    }
+  }
+  const cloned = /* @__PURE__ */ Object.create(null);
+  for (const [key, entryValue] of Object.entries(value)) {
+    cloned[key] = key === "constraints" && entryValue !== void 0 ? cloneConstraints(entryValue, orient, appendPropertyPath(path, key)) : entryValue;
+  }
+  return Object.freeze(cloned);
+};
+var cloneTableSchema = (value) => {
+  const orient = "table";
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("`table.schema` must be an object.", {
+      orient,
+      path: "$.schema",
+      value
+    });
+  }
+  if (!Array.isArray(value.fields)) {
+    throw new JsonFrameValidationError("`table.schema.fields` must be an array.", {
+      orient,
+      path: "$.schema.fields",
+      value: value.fields
+    });
+  }
+  const fields = freezeArray3(value.fields.map((field, index) => cloneTableField(field, index)));
+  const seenFieldNames = /* @__PURE__ */ new Set();
+  for (const field of fields) {
+    if (seenFieldNames.has(field.name)) {
+      throw new JsonFrameValidationError("Table Schema field names must be unique.", {
+        orient,
+        path: "$.schema.fields",
+        column: field.name,
+        value: field.name
+      });
+    }
+    seenFieldNames.add(field.name);
+  }
+  let primaryKey;
+  if (value.primaryKey !== void 0) {
+    if (!Array.isArray(value.primaryKey)) {
+      throw new JsonFrameValidationError("`table.schema.primaryKey` must be an array of strings when present.", {
+        orient,
+        path: "$.schema.primaryKey",
+        value: value.primaryKey
+      });
+    }
+    primaryKey = freezeArray3(
+      value.primaryKey.map((entryValue, index) => {
+        if (typeof entryValue !== "string") {
+          throw new JsonFrameValidationError("`table.schema.primaryKey` entries must be strings.", {
+            orient,
+            path: appendIndexPath("$.schema.primaryKey", index),
+            value: entryValue
+          });
+        }
+        return entryValue;
+      })
+    );
+  }
+  if (primaryKey !== void 0 && primaryKey.length > 1) {
+    throw new UnsupportedFeatureError("MultiIndex table payloads are not supported.", "multi-index", {
+      orient,
+      path: "$.schema.primaryKey",
+      value: primaryKey
+    });
+  }
+  if (value.pandas_version !== void 0 && typeof value.pandas_version !== "string") {
+    throw new JsonFrameValidationError("`table.schema.pandas_version` must be a string when present.", {
+      orient,
+      path: "$.schema.pandas_version",
+      value: value.pandas_version
+    });
+  }
+  const cloned = /* @__PURE__ */ Object.create(null);
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key === "fields") {
+      cloned[key] = fields;
+    } else if (key === "primaryKey") {
+      cloned[key] = primaryKey;
+    } else {
+      cloned[key] = entryValue;
+    }
+  }
+  return Object.freeze(cloned);
+};
+var parseTable = (value, orient) => {
+  if (!isPlainObject(value)) {
+    throw new JsonFrameValidationError("`table` payloads must be objects.", { orient, path: "$", value });
+  }
+  const schema = cloneTableSchema(value.schema);
+  if (!Array.isArray(value.data)) {
+    throw new JsonFrameValidationError("`table.data` must be an array of row objects.", {
+      orient,
+      path: "$.data",
+      value: value.data
+    });
+  }
+  const primaryKey = schema.primaryKey?.[0];
+  if (primaryKey !== void 0 && !schema.fields.some((field) => field.name === primaryKey)) {
+    throw new JsonFrameValidationError("`table.schema.primaryKey` must reference a declared field.", {
+      orient,
+      path: "$.schema.primaryKey",
+      column: primaryKey,
+      value: schema.primaryKey
+    });
+  }
+  const columns = schema.fields.filter((field) => field.name !== primaryKey).map((field) => field.name);
+  const data = initializeData(columns);
+  const fieldNames = new Set(schema.fields.map((field) => field.name));
+  const index = [];
+  const indexKind = primaryKey === void 0 ? "synthetic" : "source";
+  for (let rowIndex = 0; rowIndex < value.data.length; rowIndex += 1) {
+    const row = value.data[rowIndex];
+    const rowPath = appendIndexPath("$.data", rowIndex);
+    if (!isPlainObject(row)) {
+      throw new JsonFrameValidationError("`table.data` rows must be objects.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        value: row
+      });
+    }
+    for (const key of Object.keys(row)) {
+      if (!fieldNames.has(key)) {
+        throw new JsonFrameValidationError("`table.data` rows must not include fields missing from `schema.fields`.", {
+          orient,
+          path: appendPropertyPath(rowPath, key),
+          row: rowIndex,
+          column: key,
+          value: row[key]
+        });
+      }
+    }
+    if (primaryKey === void 0) {
+      index.push(rowIndex);
+    } else if (!hasOwn2.call(row, primaryKey)) {
+      throw new JsonFrameValidationError("`table.data` rows must include the primary-key field.", {
+        orient,
+        path: rowPath,
+        row: rowIndex,
+        column: primaryKey,
+        value: row
+      });
+    } else {
+      index.push(
+        assertSupportedIndexLabel(row[primaryKey], orient, appendPropertyPath(rowPath, primaryKey))
+      );
+    }
+    for (const column of columns) {
+      data.get(column).push(hasOwn2.call(row, column) ? row[column] : null);
+    }
+  }
+  return finalizeFrame({
+    orient,
+    columns,
+    index,
+    indexKind,
+    data,
+    tableSchema: schema,
+    ...primaryKey === void 0 ? {} : { tableIndexField: primaryKey }
+  });
+};
+var parseInput = (input, options) => {
+  const parsedValue = (() => {
+    if (typeof input !== "string") {
+      return input;
+    }
+    try {
+      return JSON.parse(input);
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        throw new JsonFrameParseError("Failed to parse JSON input.", error);
+      }
+      throw error;
+    }
+  })();
+  const jsonValue = validateJsonCompatible(parsedValue);
+  const orient = options.orient === "auto" ? detectOrient(jsonValue) : options.orient;
+  switch (orient) {
+    case "records":
+      return parseRecords(jsonValue, orient);
+    case "index":
+      return parseIndex(jsonValue, orient);
+    case "columns":
+      return parseColumns(jsonValue, orient);
+    case "values":
+      return parseValues(jsonValue, options, orient);
+    case "split":
+      return parseSplit(jsonValue, orient);
+    case "table":
+      return parseTable(jsonValue, orient);
+    default: {
+      const exhaustive = orient;
+      throw new JsonFrameValidationError("Unsupported orient.", { value: exhaustive });
+    }
+  }
+};
+
+// src/api.ts
+function fromOrient(input, options) {
+  const normalized = normalizeFromOrientOptions(options);
+  const parsed = parseInput(input, normalized);
+  return createDataFrame(createFrameState(parsed, normalized), normalized.packThreshold);
+}
+export {
+  AmbiguousOrientError,
+  ExportKeyCollisionError,
+  JsonFrameError,
+  JsonFrameOptionError,
+  JsonFrameParseError,
+  JsonFrameValidationError,
+  UnsupportedFeatureError,
+  fromOrient
+};