@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-ZTAFAHY3.js

@@ -0,0 +1,653 @@
+import {
+  drawingColorSchema,
+  drawingUpdateSchema
+} from "./chunk-AELXRNM6.js";
+import {
+  MSO_LANGUAGE_ID
+} from "./chunk-4ATHODCG.js";
+import {
+  MSO_TEXT_UNDERLINE_TYPE,
+  validateTextRunOptions
+} from "./chunk-JHAY3KYC.js";
+import {
+  validateDrawingUpdate
+} from "./chunk-A3XE767Q.js";
+import {
+  defineEnum,
+  defineXmlEnum
+} from "./chunk-SEK43FRN.js";
+import {
+  Length
+} from "./chunk-I6AMDG2T.js";
+import {
+  OfficeError,
+  PropertyAccessError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/chart-font-operations.ts
+var owners = [
+  "chart",
+  "legend",
+  "title",
+  "categoryAxisTitle",
+  "valueAxisTitle",
+  "categoryTickLabels",
+  "valueTickLabels",
+  "dataLabels",
+  "dataLabel"
+];
+var symbols = (definition) => Object.entries(definition).filter(([key, value]) => typeof value === "number" && key !== "MIXED").map(([key]) => key);
+var fields = {
+  bold: { type: ["boolean", "null"] },
+  italic: { type: ["boolean", "null"] },
+  name: { type: ["string", "null"], minLength: 1 },
+  size: {
+    anyOf: [
+      { type: "null" },
+      ...Object.entries({ emu: 12700, in: 1 / 72, cm: 2.54 / 72, mm: 25.4 / 72, pt: 1 }).map(
+        ([unit, perPoint]) => ({
+          type: "object",
+          additionalProperties: false,
+          required: ["value", "unit"],
+          properties: {
+            value: { type: "number", minimum: perPoint, maximum: 4e3 * perPoint },
+            unit: { const: unit }
+          }
+        })
+      )
+    ]
+  },
+  underline: { anyOf: [{ type: ["boolean", "null"] }, { enum: symbols(MSO_TEXT_UNDERLINE_TYPE) }] },
+  languageId: { enum: [...symbols(MSO_LANGUAGE_ID), null] },
+  color: drawingColorSchema,
+  fill: drawingUpdateSchema.properties.fill
+};
+var chartFontUpdateSchema = {
+  oneOf: owners.map((owner) => ({
+    type: "object",
+    additionalProperties: false,
+    required: [
+      "owner",
+      ...owner === "dataLabels" ? ["plot"] : owner === "dataLabel" ? ["series", "point"] : []
+    ],
+    properties: {
+      owner: { const: owner },
+      ...fields,
+      ...owner === "dataLabels" ? { plot: { type: "integer", minimum: 0 } } : owner === "dataLabel" ? { series: { type: "integer", minimum: 0 }, point: { type: "integer", minimum: 0 } } : {}
+    },
+    anyOf: Object.keys(fields).map((key) => ({ required: [key] })),
+    not: { required: ["color", "fill"] }
+  }))
+};
+function invalid() {
+  throw new OfficeError("invalid-value", "Invalid chart font update.", "usage");
+}
+function plain(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") return;
+  if (ancestors.has(value) || ancestors.size >= 64) invalid();
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    if (Object.getPrototypeOf(value) !== Array.prototype || value.length > 1e4) invalid();
+    for (const key of Reflect.ownKeys(value)) {
+      if (key === "length") continue;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (typeof key !== "string" || !Number.isSafeInteger(Number(key)) || String(Number(key)) !== key || Number(key) < 0 || Number(key) >= value.length || !("value" in descriptor) || !descriptor.enumerable)
+        invalid();
+      plain(descriptor.value, ancestors);
+    }
+    for (let i = 0; i < value.length; i++) if (!Object.hasOwn(value, String(i))) invalid();
+  } else {
+    if (![Object.prototype, null].includes(Object.getPrototypeOf(value))) invalid();
+    for (const key of Reflect.ownKeys(value)) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (typeof key !== "string" || !("value" in descriptor) || !descriptor.enumerable || descriptor.value === void 0)
+        invalid();
+      plain(descriptor.value, ancestors);
+    }
+  }
+  ancestors.delete(value);
+}
+function size(value) {
+  if (!value || typeof value !== "object" || Object.keys(value).some((key) => !["value", "unit"].includes(key)) || typeof value.value !== "number" || !Number.isFinite(value.value))
+    invalid();
+  const factors = { emu: 1, in: 914400, cm: 36e4, mm: 36e3, pt: 12700 };
+  if (!Object.hasOwn(factors, value.unit)) invalid();
+  return new Length(value.value * factors[value.unit]);
+}
+function enumValue(definition, name) {
+  if (typeof name !== "string" || !Object.hasOwn(definition, name) || name === "MIXED") invalid();
+  const result = definition[name];
+  if (typeof result !== "number") invalid();
+  return result;
+}
+function validateChartFontUpdate(value) {
+  plain(value);
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid();
+  const update = value;
+  if (!owners.includes(update.owner)) invalid();
+  const selectors = update.owner === "dataLabels" ? ["plot"] : update.owner === "dataLabel" ? ["series", "point"] : [];
+  if (Object.keys(update).some(
+    (key) => !["owner", ...Object.keys(fields), ...selectors].includes(key)
+  ) || !Object.keys(fields).some((key) => Object.hasOwn(update, key)))
+    invalid();
+  for (const key of selectors) {
+    const v = update[key];
+    if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0) invalid();
+  }
+  if (update.color !== void 0 && update.fill !== void 0) invalid();
+  const formatting = {
+    ...update.bold === void 0 ? {} : { bold: update.bold },
+    ...update.italic === void 0 ? {} : { italic: update.italic },
+    ...update.name === void 0 ? {} : { font: update.name },
+    ...update.size === void 0 ? {} : { size: update.size === null ? null : size(update.size).pt },
+    ...update.underline === void 0 ? {} : {
+      underline: typeof update.underline === "string" ? enumValue(MSO_TEXT_UNDERLINE_TYPE, update.underline) : update.underline
+    },
+    ...update.languageId === void 0 ? {} : {
+      language: update.languageId === null || update.languageId === "NONE" ? null : MSO_LANGUAGE_ID.to_xml(
+        enumValue(MSO_LANGUAGE_ID, update.languageId)
+      )
+    }
+  };
+  if (Object.keys(formatting).length) validateTextRunOptions(formatting);
+  if (update.color !== void 0)
+    validateDrawingUpdate({ fill: { kind: "solid", color: update.color } });
+  if (update.fill !== void 0) validateDrawingUpdate({ fill: update.fill });
+}
+function fontFor(chart, update) {
+  switch (update.owner) {
+    case "chart":
+      return chart.font;
+    case "legend": {
+      const legend = chart.legend;
+      if (!legend) throw new PropertyAccessError("Chart has no legend.");
+      return legend.font;
+    }
+    case "title":
+      return chart.chart_title.text_frame.paragraphs[0].font;
+    case "categoryAxisTitle":
+      return chart.category_axis.axis_title.text_frame.paragraphs[0].font;
+    case "valueAxisTitle":
+      return chart.value_axis.axis_title.text_frame.paragraphs[0].font;
+    case "categoryTickLabels":
+      return chart.category_axis.tick_labels.font;
+    case "valueTickLabels":
+      return chart.value_axis.tick_labels.font;
+    case "dataLabels":
+      return chart.plots.at(update.plot).data_labels.font;
+    case "dataLabel":
+      return chart.series.at(update.series).points.at(update.point).data_label.font;
+  }
+}
+function applyChartFontUpdate(chart, update) {
+  validateChartFontUpdate(update);
+  const font = fontFor(chart, update);
+  if (update.bold !== void 0) font.bold = update.bold;
+  if (update.italic !== void 0) font.italic = update.italic;
+  if (update.name !== void 0) font.name = update.name;
+  if (update.size !== void 0) font.size = update.size === null ? null : size(update.size);
+  if (update.underline !== void 0)
+    font.underline = typeof update.underline === "string" ? enumValue(MSO_TEXT_UNDERLINE_TYPE, update.underline) : update.underline;
+  if (update.languageId !== void 0)
+    font.language_id = update.languageId === null ? null : enumValue(MSO_LANGUAGE_ID, update.languageId);
+  if (update.color !== void 0) font.fill.apply({ kind: "solid", color: update.color });
+  if (update.fill !== void 0) font.fill.apply(update.fill);
+}
+
+// packages/safe-bash-presentation-engine/src/chart-enums.ts
+var XL_AXIS_CROSSESValues = /* @__PURE__ */ ((XL_AXIS_CROSSESValues2) => {
+  XL_AXIS_CROSSESValues2[XL_AXIS_CROSSESValues2["AUTOMATIC"] = -4105] = "AUTOMATIC";
+  XL_AXIS_CROSSESValues2[XL_AXIS_CROSSESValues2["CUSTOM"] = -4114] = "CUSTOM";
+  XL_AXIS_CROSSESValues2[XL_AXIS_CROSSESValues2["MAXIMUM"] = 2] = "MAXIMUM";
+  XL_AXIS_CROSSESValues2[XL_AXIS_CROSSESValues2["MINIMUM"] = 4] = "MINIMUM";
+  return XL_AXIS_CROSSESValues2;
+})(XL_AXIS_CROSSESValues || {});
+var XL_AXIS_CROSSES = defineXmlEnum(XL_AXIS_CROSSESValues, {
+  "2": "max",
+  "4": "min",
+  "-4105": "autoZero",
+  "-4114": null
+});
+var XL_CATEGORY_TYPEValues = {
+  AUTOMATIC_SCALE: -4105,
+  CATEGORY_SCALE: 2,
+  TIME_SCALE: 3
+};
+var XL_CATEGORY_TYPE = defineEnum(XL_CATEGORY_TYPEValues);
+var XL_CHART_TYPEValues = {
+  THREE_D_AREA: -4098,
+  THREE_D_AREA_STACKED: 78,
+  THREE_D_AREA_STACKED_100: 79,
+  THREE_D_BAR_CLUSTERED: 60,
+  THREE_D_BAR_STACKED: 61,
+  THREE_D_BAR_STACKED_100: 62,
+  THREE_D_COLUMN: -4100,
+  THREE_D_COLUMN_CLUSTERED: 54,
+  THREE_D_COLUMN_STACKED: 55,
+  THREE_D_COLUMN_STACKED_100: 56,
+  THREE_D_LINE: -4101,
+  THREE_D_PIE: -4102,
+  THREE_D_PIE_EXPLODED: 70,
+  AREA: 1,
+  AREA_STACKED: 76,
+  AREA_STACKED_100: 77,
+  BAR_CLUSTERED: 57,
+  BAR_OF_PIE: 71,
+  BAR_STACKED: 58,
+  BAR_STACKED_100: 59,
+  BUBBLE: 15,
+  BUBBLE_THREE_D_EFFECT: 87,
+  COLUMN_CLUSTERED: 51,
+  COLUMN_STACKED: 52,
+  COLUMN_STACKED_100: 53,
+  CONE_BAR_CLUSTERED: 102,
+  CONE_BAR_STACKED: 103,
+  CONE_BAR_STACKED_100: 104,
+  CONE_COL: 105,
+  CONE_COL_CLUSTERED: 99,
+  CONE_COL_STACKED: 100,
+  CONE_COL_STACKED_100: 101,
+  CYLINDER_BAR_CLUSTERED: 95,
+  CYLINDER_BAR_STACKED: 96,
+  CYLINDER_BAR_STACKED_100: 97,
+  CYLINDER_COL: 98,
+  CYLINDER_COL_CLUSTERED: 92,
+  CYLINDER_COL_STACKED: 93,
+  CYLINDER_COL_STACKED_100: 94,
+  DOUGHNUT: -4120,
+  DOUGHNUT_EXPLODED: 80,
+  LINE: 4,
+  LINE_MARKERS: 65,
+  LINE_MARKERS_STACKED: 66,
+  LINE_MARKERS_STACKED_100: 67,
+  LINE_STACKED: 63,
+  LINE_STACKED_100: 64,
+  PIE: 5,
+  PIE_EXPLODED: 69,
+  PIE_OF_PIE: 68,
+  PYRAMID_BAR_CLUSTERED: 109,
+  PYRAMID_BAR_STACKED: 110,
+  PYRAMID_BAR_STACKED_100: 111,
+  PYRAMID_COL: 112,
+  PYRAMID_COL_CLUSTERED: 106,
+  PYRAMID_COL_STACKED: 107,
+  PYRAMID_COL_STACKED_100: 108,
+  RADAR: -4151,
+  RADAR_FILLED: 82,
+  RADAR_MARKERS: 81,
+  STOCK_HLC: 88,
+  STOCK_OHLC: 89,
+  STOCK_VHLC: 90,
+  STOCK_VOHLC: 91,
+  SURFACE: 83,
+  SURFACE_TOP_VIEW: 85,
+  SURFACE_TOP_VIEW_WIREFRAME: 86,
+  SURFACE_WIREFRAME: 84,
+  XY_SCATTER: -4169,
+  XY_SCATTER_LINES: 74,
+  XY_SCATTER_LINES_NO_MARKERS: 75,
+  XY_SCATTER_SMOOTH: 72,
+  XY_SCATTER_SMOOTH_NO_MARKERS: 73
+};
+var XL_CHART_TYPE = defineEnum(XL_CHART_TYPEValues);
+var XL_DATA_LABEL_POSITIONValues = {
+  ABOVE: 0,
+  BELOW: 1,
+  BEST_FIT: 5,
+  CENTER: -4108,
+  INSIDE_BASE: 4,
+  INSIDE_END: 3,
+  LEFT: -4131,
+  MIXED: 6,
+  OUTSIDE_END: 2,
+  RIGHT: -4152
+};
+var XL_DATA_LABEL_POSITION = defineXmlEnum(XL_DATA_LABEL_POSITIONValues, {
+  "0": "t",
+  "1": "b",
+  "2": "outEnd",
+  "3": "inEnd",
+  "4": "inBase",
+  "5": "bestFit",
+  "6": null,
+  "-4108": "ctr",
+  "-4131": "l",
+  "-4152": "r"
+});
+var XL_LEGEND_POSITIONValues = {
+  BOTTOM: -4107,
+  CORNER: 2,
+  CUSTOM: -4161,
+  LEFT: -4131,
+  RIGHT: -4152,
+  TOP: -4160
+};
+var XL_LEGEND_POSITION = defineXmlEnum(XL_LEGEND_POSITIONValues, {
+  "2": "tr",
+  "-4107": "b",
+  "-4161": null,
+  "-4131": "l",
+  "-4152": "r",
+  "-4160": "t"
+});
+var XL_MARKER_STYLEValues = {
+  AUTOMATIC: -4105,
+  CIRCLE: 8,
+  DASH: -4115,
+  DIAMOND: 2,
+  DOT: -4118,
+  NONE: -4142,
+  PICTURE: -4147,
+  PLUS: 9,
+  SQUARE: 1,
+  STAR: 5,
+  TRIANGLE: 3,
+  X: -4168
+};
+var XL_MARKER_STYLE = defineXmlEnum(XL_MARKER_STYLEValues, {
+  "1": "square",
+  "2": "diamond",
+  "3": "triangle",
+  "5": "star",
+  "8": "circle",
+  "9": "plus",
+  "-4105": "auto",
+  "-4115": "dash",
+  "-4118": "dot",
+  "-4142": "none",
+  "-4147": "picture",
+  "-4168": "x"
+});
+var XL_TICK_LABEL_POSITIONValues = {
+  HIGH: -4127,
+  LOW: -4134,
+  NEXT_TO_AXIS: 4,
+  NONE: -4142
+};
+var XL_TICK_LABEL_POSITION = defineXmlEnum(XL_TICK_LABEL_POSITIONValues, {
+  "4": "nextTo",
+  "-4127": "high",
+  "-4134": "low",
+  "-4142": "none"
+});
+var XL_TICK_MARKValues = {
+  CROSS: 4,
+  INSIDE: 2,
+  NONE: -4142,
+  OUTSIDE: 3
+};
+var XL_TICK_MARK = defineXmlEnum(XL_TICK_MARKValues, {
+  "2": "in",
+  "3": "out",
+  "4": "cross",
+  "-4142": "none"
+});
+
+// packages/safe-bash-presentation-engine/src/chart-object-operations.ts
+var boolean = { type: "boolean" };
+var number = { type: ["number", "null"] };
+var text = { type: "string" };
+var index = { type: "integer", minimum: 0 };
+var symbols2 = (values, excluded = []) => ({
+  enum: Object.entries(values).filter(([key, value]) => typeof value === "number" && !excluded.includes(key)).map(([key]) => key)
+});
+var axis = {
+  hasTitle: boolean,
+  hasMajorGridlines: boolean,
+  hasMinorGridlines: boolean,
+  majorTickMark: symbols2(XL_TICK_MARK),
+  minorTickMark: symbols2(XL_TICK_MARK),
+  maximumScale: number,
+  minimumScale: number,
+  reverseOrder: boolean,
+  tickLabelPosition: symbols2(XL_TICK_LABEL_POSITION),
+  visible: boolean
+};
+var formatOwners = [
+  "title",
+  "legend",
+  "categoryAxis",
+  "valueAxis",
+  "categoryAxisTitle",
+  "valueAxisTitle",
+  "categoryMajorGridlines",
+  "valueMajorGridlines",
+  "series",
+  "point",
+  "marker"
+];
+var definitions = {
+  format: {
+    selectors: ["owner", "series", "point"],
+    required: ["owner", "drawing"],
+    fields: {
+      owner: { enum: formatOwners },
+      series: index,
+      point: index,
+      drawing: { type: "object" }
+    }
+  },
+  chart: {
+    fields: {
+      hasTitle: boolean,
+      hasLegend: boolean,
+      style: { type: ["integer", "null"], minimum: 1, maximum: 48 }
+    }
+  },
+  title: { fields: { hasTextFrame: boolean, text } },
+  legend: {
+    fields: {
+      position: symbols2(XL_LEGEND_POSITION, ["CUSTOM"]),
+      includeInLayout: { type: ["boolean", "null"] },
+      horzOffset: { type: ["number", "null"], minimum: -1, maximum: 1 }
+    }
+  },
+  categoryAxis: { fields: axis },
+  valueAxis: {
+    fields: {
+      ...axis,
+      crosses: symbols2(XL_AXIS_CROSSES),
+      crossesAt: number,
+      majorUnit: { ...number, exclusiveMinimum: 0 },
+      minorUnit: { ...number, exclusiveMinimum: 0 }
+    }
+  },
+  axisTitle: {
+    selectors: ["axis"],
+    required: ["axis"],
+    fields: { axis: { enum: ["category", "value"] }, hasTextFrame: boolean, text }
+  },
+  tickLabels: {
+    selectors: ["axis"],
+    required: ["axis"],
+    fields: {
+      axis: { enum: ["category", "value"] },
+      numberFormat: text,
+      numberFormatIsLinked: boolean,
+      offset: { type: "integer", minimum: 0, maximum: 1e3 }
+    }
+  },
+  plot: {
+    selectors: ["plot"],
+    required: ["plot"],
+    fields: {
+      plot: index,
+      hasDataLabels: boolean,
+      varyByCategories: boolean,
+      gapWidth: { type: "integer", minimum: 0, maximum: 500 },
+      overlap: { type: "integer", minimum: -100, maximum: 100 },
+      bubbleScale: { type: ["integer", "null"], minimum: 0, maximum: 300 }
+    }
+  },
+  series: {
+    selectors: ["series"],
+    required: ["series"],
+    fields: { series: index, invertIfNegative: boolean, smooth: boolean }
+  },
+  marker: {
+    selectors: ["series", "point"],
+    required: ["series"],
+    fields: {
+      series: index,
+      point: index,
+      style: { enum: [...symbols2(XL_MARKER_STYLE).enum, null] },
+      size: { type: ["integer", "null"], minimum: 2, maximum: 72 }
+    }
+  },
+  dataLabels: {
+    selectors: ["plot"],
+    required: ["plot"],
+    fields: {
+      plot: index,
+      position: { enum: [...symbols2(XL_DATA_LABEL_POSITION, ["MIXED"]).enum, null] },
+      numberFormat: text,
+      numberFormatIsLinked: boolean,
+      showCategoryName: boolean,
+      showLegendKey: boolean,
+      showPercentage: boolean,
+      showSeriesName: boolean,
+      showValue: boolean
+    }
+  },
+  dataLabel: {
+    selectors: ["series", "point"],
+    required: ["series", "point"],
+    fields: {
+      series: index,
+      point: index,
+      position: { enum: [...symbols2(XL_DATA_LABEL_POSITION, ["MIXED"]).enum, null] },
+      hasTextFrame: boolean,
+      text
+    }
+  }
+};
+var chartObjectSchema = {
+  type: "array",
+  minItems: 1,
+  maxItems: 1e4,
+  items: {
+    oneOf: [
+      ...chartFontUpdateSchema.oneOf.map((schema) => ({
+        ...schema,
+        required: ["target", ...schema.required],
+        properties: { target: { const: "font" }, ...schema.properties }
+      })),
+      ...Object.entries(definitions).map(([target, definition]) => ({
+        type: "object",
+        additionalProperties: false,
+        required: ["target", ...definition.required ?? []],
+        properties: {
+          target: { const: target },
+          ...definition.fields,
+          ...target === "format" ? { drawing: drawingUpdateSchema } : {}
+        },
+        ...target === "format" ? {
+          allOf: [
+            {
+              if: { properties: { owner: { enum: ["series", "point", "marker"] } } },
+              then: { required: ["series"] },
+              else: { not: { anyOf: [{ required: ["series"] }, { required: ["point"] }] } }
+            },
+            {
+              if: { properties: { owner: { const: "point" } } },
+              then: { required: ["point"] }
+            },
+            {
+              if: { properties: { owner: { const: "series" } } },
+              then: { not: { required: ["point"] } }
+            }
+          ]
+        } : {},
+        anyOf: Object.keys(definition.fields).filter((key) => !definition.selectors?.includes(key)).map((key) => ({ required: [key] }))
+      }))
+    ]
+  }
+};
+function invalid2() {
+  throw new OfficeError("invalid-value", "Invalid chart object update.", "usage");
+}
+function validateChartObjectUpdates(value) {
+  if (!Array.isArray(value) || !value.length || value.length > 1e4 || Object.getPrototypeOf(value) !== Array.prototype)
+    invalid2();
+  if (Reflect.ownKeys(value).length !== value.length + 1) invalid2();
+  for (let i = 0; i < value.length; i++) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+    if (!descriptor || !("value" in descriptor)) invalid2();
+  }
+  for (const edit of value) {
+    if (!edit || typeof edit !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(edit)))
+      invalid2();
+    for (const key of Reflect.ownKeys(edit))
+      if (typeof key !== "string" || !("value" in Object.getOwnPropertyDescriptor(edit, key)) || !Object.getOwnPropertyDescriptor(edit, key).enumerable)
+        invalid2();
+    if (edit.target === "font") {
+      const { target: ignoredTarget, ...font } = edit;
+      validateChartFontUpdate(font);
+      continue;
+    }
+    const definition = typeof edit.target === "string" && Object.hasOwn(definitions, edit.target) ? definitions[edit.target] : void 0;
+    if (!definition || definition.required?.some((key) => !Object.hasOwn(edit, key))) invalid2();
+    if (!Object.keys(edit).some((key) => key !== "target" && !definition.selectors?.includes(key)))
+      invalid2();
+    if (edit.target === "format") {
+      const seriesOwner = ["series", "point", "marker"].includes(edit.owner);
+      if (seriesOwner ? !Object.hasOwn(edit, "series") : Object.hasOwn(edit, "series") || Object.hasOwn(edit, "point"))
+        invalid2();
+      if (edit.owner === "point" && !Object.hasOwn(edit, "point") || edit.owner === "series" && Object.hasOwn(edit, "point"))
+        invalid2();
+    }
+    for (const [key, item] of Object.entries(edit)) {
+      if (key === "target") continue;
+      if (key === "drawing" && edit.target === "format") {
+        plainDrawing(item);
+        validateDrawingUpdate(item);
+        continue;
+      }
+      const field = Object.hasOwn(definition.fields, key) ? definition.fields[key] : void 0;
+      if (!field) invalid2();
+      if (field.enum) {
+        if (!field.enum.includes(item)) invalid2();
+        continue;
+      }
+      const types = Array.isArray(field.type) ? field.type : [field.type];
+      if (item === null ? !types.includes("null") : typeof item === "number" ? !Number.isFinite(item) || !(types.includes("number") || types.includes("integer") && Number.isInteger(item)) : !types.includes(typeof item))
+        invalid2();
+      if (typeof item === "number" && (field.minimum !== void 0 && item < field.minimum || field.maximum !== void 0 && item > field.maximum || field.exclusiveMinimum !== void 0 && item <= field.exclusiveMinimum))
+        invalid2();
+    }
+  }
+}
+function plainDrawing(value, depth = 0) {
+  if (depth > 16) invalid2();
+  if (value === null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    if (Object.getPrototypeOf(value) !== Array.prototype || value.length > 1e4 || Reflect.ownKeys(value).length !== value.length + 1)
+      invalid2();
+    for (let i = 0; i < value.length; i++) {
+      const d = Object.getOwnPropertyDescriptor(value, String(i));
+      if (!d || !("value" in d)) invalid2();
+      plainDrawing(d.value, depth + 1);
+    }
+    return;
+  }
+  if (![Object.prototype, null].includes(Object.getPrototypeOf(value))) invalid2();
+  for (const key of Reflect.ownKeys(value)) {
+    const d = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || !("value" in d) || !d.enumerable) invalid2();
+    plainDrawing(d.value, depth + 1);
+  }
+}
+
+export {
+  applyChartFontUpdate,
+  XL_AXIS_CROSSES,
+  XL_CATEGORY_TYPE,
+  XL_CHART_TYPE,
+  XL_DATA_LABEL_POSITION,
+  XL_LEGEND_POSITION,
+  XL_MARKER_STYLE,
+  XL_TICK_LABEL_POSITION,
+  XL_TICK_MARK,
+  chartObjectSchema,
+  validateChartObjectUpdates
+};