document-model.js 3.1.0 → 3.3.0

package/dist/math-B7gZJeND.d.cts

@@ -0,0 +1,210 @@
+import { z } from "zod";
+//#region src/math.d.ts
+declare const ExactRationalSchema: z.ZodObject<{
+  numerator: z.ZodString;
+  denominator: z.ZodString;
+}, z.core.$strip>;
+type ExactRational = z.infer<typeof ExactRationalSchema>;
+declare const SI_BASE_DIMENSIONS: readonly ["length", "mass", "time", "electricCurrent", "thermodynamicTemperature", "amountOfSubstance", "luminousIntensity"];
+type SiBaseDimension = (typeof SI_BASE_DIMENSIONS)[number];
+declare const DimensionVectorSchema: z.ZodRecord<z.ZodEnum<{
+  time: "time";
+  length: "length";
+  mass: "mass";
+  electricCurrent: "electricCurrent";
+  thermodynamicTemperature: "thermodynamicTemperature";
+  amountOfSubstance: "amountOfSubstance";
+  luminousIntensity: "luminousIntensity";
+}> & z.core.$partial, z.ZodNumber>;
+type DimensionVector = z.infer<typeof DimensionVectorSchema>;
+declare const MathUnitSchema: z.ZodObject<{
+  id: z.ZodString;
+  symbol: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  dimension: z.ZodRecord<z.ZodEnum<{
+    time: "time";
+    length: "length";
+    mass: "mass";
+    electricCurrent: "electricCurrent";
+    thermodynamicTemperature: "thermodynamicTemperature";
+    amountOfSubstance: "amountOfSubstance";
+    luminousIntensity: "luminousIntensity";
+  }> & z.core.$partial, z.ZodNumber>;
+  factorToSi: z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>;
+  offsetToSi: z.ZodOptional<z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>>;
+  context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MathUnit = z.infer<typeof MathUnitSchema>;
+declare const MathNormalisationContextSchema: z.ZodObject<{
+  id: z.ZodString;
+  bases: z.ZodArray<z.ZodObject<{
+    unit: z.ZodString;
+    value: z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MathNormalisationContext = z.infer<typeof MathNormalisationContextSchema>;
+declare const MathSymbolEntrySchema: z.ZodObject<{
+  glyph: z.ZodString;
+  scope: z.ZodString;
+  id: z.ZodString;
+  quantityKind: z.ZodOptional<z.ZodString>;
+  preferredUnit: z.ZodOptional<z.ZodString>;
+  definitionSource: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MathSymbolEntry = z.infer<typeof MathSymbolEntrySchema>;
+declare const SymbolTableSchema: z.ZodObject<{
+  symbols: z.ZodArray<z.ZodObject<{
+    glyph: z.ZodString;
+    scope: z.ZodString;
+    id: z.ZodString;
+    quantityKind: z.ZodOptional<z.ZodString>;
+    preferredUnit: z.ZodOptional<z.ZodString>;
+    definitionSource: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  units: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    symbol: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodRecord<z.ZodEnum<{
+      time: "time";
+      length: "length";
+      mass: "mass";
+      electricCurrent: "electricCurrent";
+      thermodynamicTemperature: "thermodynamicTemperature";
+      amountOfSubstance: "amountOfSubstance";
+      luminousIntensity: "luminousIntensity";
+    }> & z.core.$partial, z.ZodNumber>;
+    factorToSi: z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>;
+    offsetToSi: z.ZodOptional<z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>>;
+    context: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  contexts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    bases: z.ZodArray<z.ZodObject<{
+      unit: z.ZodString;
+      value: z.ZodObject<{
+        numerator: z.ZodString;
+        denominator: z.ZodString;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type SymbolTable = z.infer<typeof SymbolTableSchema>;
+declare const MathPresentationSchema: z.ZodObject<{
+  latex: z.ZodString;
+}, z.core.$strip>;
+type MathPresentation = z.infer<typeof MathPresentationSchema>;
+declare const MathProvenanceSchema: z.ZodObject<{
+  source: z.ZodString;
+  pageRef: z.ZodOptional<z.ZodString>;
+  editTrail: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type MathProvenance = z.infer<typeof MathProvenanceSchema>;
+declare const MathUncertaintySchema: z.ZodObject<{
+  magnitude: z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>;
+  unit: z.ZodOptional<z.ZodString>;
+  coverageFactor: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type MathUncertainty = z.infer<typeof MathUncertaintySchema>;
+declare const MathNumSchema: z.ZodObject<{
+  numerator: z.ZodString;
+  denominator: z.ZodString;
+  kind: z.ZodLiteral<"num">;
+}, z.core.$strip>;
+type MathNum = z.infer<typeof MathNumSchema>;
+declare const MathQtySchema: z.ZodObject<{
+  kind: z.ZodLiteral<"qty">;
+  value: z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>;
+  unit: z.ZodString;
+  uncertainty: z.ZodOptional<z.ZodObject<{
+    magnitude: z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>;
+    unit: z.ZodOptional<z.ZodString>;
+    coverageFactor: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MathQty = z.infer<typeof MathQtySchema>;
+declare const MathSymSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"sym">;
+  id: z.ZodString;
+}, z.core.$strip>;
+type MathSym = z.infer<typeof MathSymSchema>;
+declare const MathUnparsedSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"unparsed">;
+  latex: z.ZodString;
+}, z.core.$strip>;
+type MathUnparsed = z.infer<typeof MathUnparsedSchema>;
+interface MathApp {
+  kind: 'app';
+  operator: string;
+  args: MathExpression[];
+}
+interface MathSum {
+  kind: 'sum';
+  binder: string;
+  lower: MathExpression;
+  upper: MathExpression;
+  body: MathExpression;
+}
+interface MathProd {
+  kind: 'prod';
+  binder: string;
+  lower: MathExpression;
+  upper: MathExpression;
+  body: MathExpression;
+}
+interface MathMatrix {
+  kind: 'matrix';
+  rows: MathExpression[][];
+}
+type MathExpression = MathNum | MathQty | MathSym | MathApp | MathSum | MathProd | MathMatrix | MathUnparsed;
+declare function isMathExpression(value: unknown): value is MathExpression;
+declare const MathExpressionSchema: z.ZodCustom<MathExpression, MathExpression>;
+declare const MathAppSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"app">;
+  operator: z.ZodString;
+  args: z.ZodArray<z.ZodCustom<MathExpression, MathExpression>>;
+}, z.core.$strip>;
+declare const MathSumSchema: z.ZodObject<{
+  binder: z.ZodString;
+  lower: z.ZodCustom<MathExpression, MathExpression>;
+  upper: z.ZodCustom<MathExpression, MathExpression>;
+  body: z.ZodCustom<MathExpression, MathExpression>;
+  kind: z.ZodLiteral<"sum">;
+}, z.core.$strip>;
+declare const MathProdSchema: z.ZodObject<{
+  binder: z.ZodString;
+  lower: z.ZodCustom<MathExpression, MathExpression>;
+  upper: z.ZodCustom<MathExpression, MathExpression>;
+  body: z.ZodCustom<MathExpression, MathExpression>;
+  kind: z.ZodLiteral<"prod">;
+}, z.core.$strip>;
+declare const MathMatrixSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"matrix">;
+  rows: z.ZodArray<z.ZodArray<z.ZodCustom<MathExpression, MathExpression>>>;
+}, z.core.$strip>;
+//#endregion
+export { MathUncertaintySchema as A, MathSum as C, MathSymbolEntry as D, MathSymSchema as E, SI_BASE_DIMENSIONS as F, SiBaseDimension as I, SymbolTable as L, MathUnitSchema as M, MathUnparsed as N, MathSymbolEntrySchema as O, MathUnparsedSchema as P, SymbolTableSchema as R, MathQtySchema as S, MathSym as T, MathProd as _, MathApp as a, MathProvenanceSchema as b, MathExpressionSchema as c, MathNormalisationContext as d, MathNormalisationContextSchema as f, MathPresentationSchema as g, MathPresentation as h, ExactRationalSchema as i, MathUnit as j, MathUncertainty as k, MathMatrix as l, MathNumSchema as m, DimensionVectorSchema as n, MathAppSchema as o, MathNum as p, ExactRational as r, MathExpression as s, DimensionVector as t, MathMatrixSchema as u, MathProdSchema as v, MathSumSchema as w, MathQty as x, MathProvenance as y, isMathExpression as z };

package/dist/math-B7gZJeND.d.ts

@@ -0,0 +1,210 @@
+import { z } from "zod";
+//#region src/math.d.ts
+declare const ExactRationalSchema: z.ZodObject<{
+  numerator: z.ZodString;
+  denominator: z.ZodString;
+}, z.core.$strip>;
+type ExactRational = z.infer<typeof ExactRationalSchema>;
+declare const SI_BASE_DIMENSIONS: readonly ["length", "mass", "time", "electricCurrent", "thermodynamicTemperature", "amountOfSubstance", "luminousIntensity"];
+type SiBaseDimension = (typeof SI_BASE_DIMENSIONS)[number];
+declare const DimensionVectorSchema: z.ZodRecord<z.ZodEnum<{
+  time: "time";
+  length: "length";
+  mass: "mass";
+  electricCurrent: "electricCurrent";
+  thermodynamicTemperature: "thermodynamicTemperature";
+  amountOfSubstance: "amountOfSubstance";
+  luminousIntensity: "luminousIntensity";
+}> & z.core.$partial, z.ZodNumber>;
+type DimensionVector = z.infer<typeof DimensionVectorSchema>;
+declare const MathUnitSchema: z.ZodObject<{
+  id: z.ZodString;
+  symbol: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  dimension: z.ZodRecord<z.ZodEnum<{
+    time: "time";
+    length: "length";
+    mass: "mass";
+    electricCurrent: "electricCurrent";
+    thermodynamicTemperature: "thermodynamicTemperature";
+    amountOfSubstance: "amountOfSubstance";
+    luminousIntensity: "luminousIntensity";
+  }> & z.core.$partial, z.ZodNumber>;
+  factorToSi: z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>;
+  offsetToSi: z.ZodOptional<z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>>;
+  context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MathUnit = z.infer<typeof MathUnitSchema>;
+declare const MathNormalisationContextSchema: z.ZodObject<{
+  id: z.ZodString;
+  bases: z.ZodArray<z.ZodObject<{
+    unit: z.ZodString;
+    value: z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MathNormalisationContext = z.infer<typeof MathNormalisationContextSchema>;
+declare const MathSymbolEntrySchema: z.ZodObject<{
+  glyph: z.ZodString;
+  scope: z.ZodString;
+  id: z.ZodString;
+  quantityKind: z.ZodOptional<z.ZodString>;
+  preferredUnit: z.ZodOptional<z.ZodString>;
+  definitionSource: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MathSymbolEntry = z.infer<typeof MathSymbolEntrySchema>;
+declare const SymbolTableSchema: z.ZodObject<{
+  symbols: z.ZodArray<z.ZodObject<{
+    glyph: z.ZodString;
+    scope: z.ZodString;
+    id: z.ZodString;
+    quantityKind: z.ZodOptional<z.ZodString>;
+    preferredUnit: z.ZodOptional<z.ZodString>;
+    definitionSource: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  units: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    symbol: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    dimension: z.ZodRecord<z.ZodEnum<{
+      time: "time";
+      length: "length";
+      mass: "mass";
+      electricCurrent: "electricCurrent";
+      thermodynamicTemperature: "thermodynamicTemperature";
+      amountOfSubstance: "amountOfSubstance";
+      luminousIntensity: "luminousIntensity";
+    }> & z.core.$partial, z.ZodNumber>;
+    factorToSi: z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>;
+    offsetToSi: z.ZodOptional<z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>>;
+    context: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  contexts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    bases: z.ZodArray<z.ZodObject<{
+      unit: z.ZodString;
+      value: z.ZodObject<{
+        numerator: z.ZodString;
+        denominator: z.ZodString;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type SymbolTable = z.infer<typeof SymbolTableSchema>;
+declare const MathPresentationSchema: z.ZodObject<{
+  latex: z.ZodString;
+}, z.core.$strip>;
+type MathPresentation = z.infer<typeof MathPresentationSchema>;
+declare const MathProvenanceSchema: z.ZodObject<{
+  source: z.ZodString;
+  pageRef: z.ZodOptional<z.ZodString>;
+  editTrail: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type MathProvenance = z.infer<typeof MathProvenanceSchema>;
+declare const MathUncertaintySchema: z.ZodObject<{
+  magnitude: z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>;
+  unit: z.ZodOptional<z.ZodString>;
+  coverageFactor: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type MathUncertainty = z.infer<typeof MathUncertaintySchema>;
+declare const MathNumSchema: z.ZodObject<{
+  numerator: z.ZodString;
+  denominator: z.ZodString;
+  kind: z.ZodLiteral<"num">;
+}, z.core.$strip>;
+type MathNum = z.infer<typeof MathNumSchema>;
+declare const MathQtySchema: z.ZodObject<{
+  kind: z.ZodLiteral<"qty">;
+  value: z.ZodObject<{
+    numerator: z.ZodString;
+    denominator: z.ZodString;
+  }, z.core.$strip>;
+  unit: z.ZodString;
+  uncertainty: z.ZodOptional<z.ZodObject<{
+    magnitude: z.ZodObject<{
+      numerator: z.ZodString;
+      denominator: z.ZodString;
+    }, z.core.$strip>;
+    unit: z.ZodOptional<z.ZodString>;
+    coverageFactor: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type MathQty = z.infer<typeof MathQtySchema>;
+declare const MathSymSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"sym">;
+  id: z.ZodString;
+}, z.core.$strip>;
+type MathSym = z.infer<typeof MathSymSchema>;
+declare const MathUnparsedSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"unparsed">;
+  latex: z.ZodString;
+}, z.core.$strip>;
+type MathUnparsed = z.infer<typeof MathUnparsedSchema>;
+interface MathApp {
+  kind: 'app';
+  operator: string;
+  args: MathExpression[];
+}
+interface MathSum {
+  kind: 'sum';
+  binder: string;
+  lower: MathExpression;
+  upper: MathExpression;
+  body: MathExpression;
+}
+interface MathProd {
+  kind: 'prod';
+  binder: string;
+  lower: MathExpression;
+  upper: MathExpression;
+  body: MathExpression;
+}
+interface MathMatrix {
+  kind: 'matrix';
+  rows: MathExpression[][];
+}
+type MathExpression = MathNum | MathQty | MathSym | MathApp | MathSum | MathProd | MathMatrix | MathUnparsed;
+declare function isMathExpression(value: unknown): value is MathExpression;
+declare const MathExpressionSchema: z.ZodCustom<MathExpression, MathExpression>;
+declare const MathAppSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"app">;
+  operator: z.ZodString;
+  args: z.ZodArray<z.ZodCustom<MathExpression, MathExpression>>;
+}, z.core.$strip>;
+declare const MathSumSchema: z.ZodObject<{
+  binder: z.ZodString;
+  lower: z.ZodCustom<MathExpression, MathExpression>;
+  upper: z.ZodCustom<MathExpression, MathExpression>;
+  body: z.ZodCustom<MathExpression, MathExpression>;
+  kind: z.ZodLiteral<"sum">;
+}, z.core.$strip>;
+declare const MathProdSchema: z.ZodObject<{
+  binder: z.ZodString;
+  lower: z.ZodCustom<MathExpression, MathExpression>;
+  upper: z.ZodCustom<MathExpression, MathExpression>;
+  body: z.ZodCustom<MathExpression, MathExpression>;
+  kind: z.ZodLiteral<"prod">;
+}, z.core.$strip>;
+declare const MathMatrixSchema: z.ZodObject<{
+  kind: z.ZodLiteral<"matrix">;
+  rows: z.ZodArray<z.ZodArray<z.ZodCustom<MathExpression, MathExpression>>>;
+}, z.core.$strip>;
+//#endregion
+export { MathUncertaintySchema as A, MathSum as C, MathSymbolEntry as D, MathSymSchema as E, SI_BASE_DIMENSIONS as F, SiBaseDimension as I, SymbolTable as L, MathUnitSchema as M, MathUnparsed as N, MathSymbolEntrySchema as O, MathUnparsedSchema as P, SymbolTableSchema as R, MathQtySchema as S, MathSym as T, MathProd as _, MathApp as a, MathProvenanceSchema as b, MathExpressionSchema as c, MathNormalisationContext as d, MathNormalisationContextSchema as f, MathPresentationSchema as g, MathPresentation as h, ExactRationalSchema as i, MathUnit as j, MathUncertainty as k, MathMatrix as l, MathNumSchema as m, DimensionVectorSchema as n, MathAppSchema as o, MathNum as p, ExactRational as r, MathExpression as s, DimensionVector as t, MathMatrixSchema as u, MathProdSchema as v, MathSumSchema as w, MathQty as x, MathProvenance as y, isMathExpression as z };

package/dist/math.cjs

@@ -0,0 +1,152 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/math.ts
+const CANONICAL_SIGNED_INTEGER = /^(0|-?[1-9]\d*)$/;
+const CANONICAL_POSITIVE_INTEGER = /^[1-9]\d*$/;
+const EXACT_RATIONAL_FIELDS = {
+	numerator: zod.z.string().regex(CANONICAL_SIGNED_INTEGER),
+	denominator: zod.z.string().regex(CANONICAL_POSITIVE_INTEGER)
+};
+const ExactRationalSchema = zod.z.object(EXACT_RATIONAL_FIELDS);
+const SI_BASE_DIMENSIONS = [
+	"length",
+	"mass",
+	"time",
+	"electricCurrent",
+	"thermodynamicTemperature",
+	"amountOfSubstance",
+	"luminousIntensity"
+];
+const DimensionVectorSchema = zod.z.partialRecord(zod.z.enum(SI_BASE_DIMENSIONS), zod.z.number().int());
+const MathUnitSchema = zod.z.object({
+	id: zod.z.string(),
+	symbol: zod.z.string(),
+	name: zod.z.string().optional(),
+	dimension: DimensionVectorSchema,
+	factorToSi: ExactRationalSchema,
+	offsetToSi: ExactRationalSchema.optional(),
+	context: zod.z.string().optional()
+});
+const MathNormalisationContextSchema = zod.z.object({
+	id: zod.z.string(),
+	bases: zod.z.array(zod.z.object({
+		unit: zod.z.string(),
+		value: ExactRationalSchema
+	}))
+});
+const MathSymbolEntrySchema = zod.z.object({
+	glyph: zod.z.string(),
+	scope: zod.z.string(),
+	id: zod.z.string(),
+	quantityKind: zod.z.string().optional(),
+	preferredUnit: zod.z.string().optional(),
+	definitionSource: zod.z.string().optional()
+});
+const SymbolTableSchema = zod.z.object({
+	symbols: zod.z.array(MathSymbolEntrySchema),
+	units: zod.z.array(MathUnitSchema),
+	contexts: zod.z.array(MathNormalisationContextSchema).optional()
+});
+const MathPresentationSchema = zod.z.object({ latex: zod.z.string() });
+const MathProvenanceSchema = zod.z.object({
+	source: zod.z.string(),
+	pageRef: zod.z.string().optional(),
+	editTrail: zod.z.array(zod.z.string())
+});
+const MathUncertaintySchema = zod.z.object({
+	magnitude: ExactRationalSchema,
+	unit: zod.z.string().optional(),
+	coverageFactor: zod.z.number().positive().optional()
+});
+const MathNumSchema = zod.z.object({
+	kind: zod.z.literal("num"),
+	...EXACT_RATIONAL_FIELDS
+});
+const MathQtySchema = zod.z.object({
+	kind: zod.z.literal("qty"),
+	value: ExactRationalSchema,
+	unit: zod.z.string(),
+	uncertainty: MathUncertaintySchema.optional()
+});
+const MathSymSchema = zod.z.object({
+	kind: zod.z.literal("sym"),
+	id: zod.z.string()
+});
+const MathUnparsedSchema = zod.z.object({
+	kind: zod.z.literal("unparsed"),
+	latex: zod.z.string()
+});
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isExactRational(value) {
+	return isRecord(value) && typeof value.numerator === "string" && CANONICAL_SIGNED_INTEGER.test(value.numerator) && typeof value.denominator === "string" && CANONICAL_POSITIVE_INTEGER.test(value.denominator);
+}
+function isMathUncertainty(value) {
+	return isRecord(value) && isExactRational(value.magnitude) && (value.unit === void 0 || typeof value.unit === "string") && (value.coverageFactor === void 0 || typeof value.coverageFactor === "number" && value.coverageFactor > 0);
+}
+function isMathExpression(value) {
+	if (!isRecord(value)) return false;
+	const kind = value.kind;
+	if (kind === "num") return typeof value.numerator === "string" && CANONICAL_SIGNED_INTEGER.test(value.numerator) && typeof value.denominator === "string" && CANONICAL_POSITIVE_INTEGER.test(value.denominator);
+	if (kind === "qty") return isExactRational(value.value) && typeof value.unit === "string" && (value.uncertainty === void 0 || isMathUncertainty(value.uncertainty));
+	if (kind === "sym") return typeof value.id === "string";
+	if (kind === "app") return typeof value.operator === "string" && Array.isArray(value.args) && value.args.every(isMathExpression);
+	if (kind === "sum" || kind === "prod") return typeof value.binder === "string" && isMathExpression(value.lower) && isMathExpression(value.upper) && isMathExpression(value.body);
+	if (kind === "matrix") {
+		if (!Array.isArray(value.rows)) return false;
+		const widths = /* @__PURE__ */ new Set();
+		for (const row of value.rows) {
+			if (!Array.isArray(row) || !row.every(isMathExpression)) return false;
+			widths.add(row.length);
+		}
+		return widths.size <= 1;
+	}
+	if (kind === "unparsed") return typeof value.latex === "string";
+	return false;
+}
+const MathExpressionSchema = zod.z.custom(isMathExpression);
+const MathAppSchema = zod.z.object({
+	kind: zod.z.literal("app"),
+	operator: zod.z.string(),
+	args: zod.z.array(MathExpressionSchema)
+});
+const BINDER_SCHEMA_FIELDS = {
+	binder: zod.z.string(),
+	lower: MathExpressionSchema,
+	upper: MathExpressionSchema,
+	body: MathExpressionSchema
+};
+const MathSumSchema = zod.z.object({
+	kind: zod.z.literal("sum"),
+	...BINDER_SCHEMA_FIELDS
+});
+const MathProdSchema = zod.z.object({
+	kind: zod.z.literal("prod"),
+	...BINDER_SCHEMA_FIELDS
+});
+const MathMatrixSchema = zod.z.object({
+	kind: zod.z.literal("matrix"),
+	rows: zod.z.array(zod.z.array(MathExpressionSchema))
+}).refine((matrix) => new Set(matrix.rows.map((row) => row.length)).size <= 1, { message: "matrix rows must all have the same number of columns" });
+//#endregion
+exports.DimensionVectorSchema = DimensionVectorSchema;
+exports.ExactRationalSchema = ExactRationalSchema;
+exports.MathAppSchema = MathAppSchema;
+exports.MathExpressionSchema = MathExpressionSchema;
+exports.MathMatrixSchema = MathMatrixSchema;
+exports.MathNormalisationContextSchema = MathNormalisationContextSchema;
+exports.MathNumSchema = MathNumSchema;
+exports.MathPresentationSchema = MathPresentationSchema;
+exports.MathProdSchema = MathProdSchema;
+exports.MathProvenanceSchema = MathProvenanceSchema;
+exports.MathQtySchema = MathQtySchema;
+exports.MathSumSchema = MathSumSchema;
+exports.MathSymSchema = MathSymSchema;
+exports.MathSymbolEntrySchema = MathSymbolEntrySchema;
+exports.MathUncertaintySchema = MathUncertaintySchema;
+exports.MathUnitSchema = MathUnitSchema;
+exports.MathUnparsedSchema = MathUnparsedSchema;
+exports.SI_BASE_DIMENSIONS = SI_BASE_DIMENSIONS;
+exports.SymbolTableSchema = SymbolTableSchema;
+exports.isMathExpression = isMathExpression;

package/dist/math.d.cts

@@ -0,0 +1,2 @@
+import { A as MathUncertaintySchema, C as MathSum, D as MathSymbolEntry, E as MathSymSchema, F as SI_BASE_DIMENSIONS, I as SiBaseDimension, L as SymbolTable, M as MathUnitSchema, N as MathUnparsed, O as MathSymbolEntrySchema, P as MathUnparsedSchema, R as SymbolTableSchema, S as MathQtySchema, T as MathSym, _ as MathProd, a as MathApp, b as MathProvenanceSchema, c as MathExpressionSchema, d as MathNormalisationContext, f as MathNormalisationContextSchema, g as MathPresentationSchema, h as MathPresentation, i as ExactRationalSchema, j as MathUnit, k as MathUncertainty, l as MathMatrix, m as MathNumSchema, n as DimensionVectorSchema, o as MathAppSchema, p as MathNum, r as ExactRational, s as MathExpression, t as DimensionVector, u as MathMatrixSchema, v as MathProdSchema, w as MathSumSchema, x as MathQty, y as MathProvenance, z as isMathExpression } from "./math-B7gZJeND.cjs";
+export { DimensionVector, DimensionVectorSchema, ExactRational, ExactRationalSchema, MathApp, MathAppSchema, MathExpression, MathExpressionSchema, MathMatrix, MathMatrixSchema, MathNormalisationContext, MathNormalisationContextSchema, MathNum, MathNumSchema, MathPresentation, MathPresentationSchema, MathProd, MathProdSchema, MathProvenance, MathProvenanceSchema, MathQty, MathQtySchema, MathSum, MathSumSchema, MathSym, MathSymSchema, MathSymbolEntry, MathSymbolEntrySchema, MathUncertainty, MathUncertaintySchema, MathUnit, MathUnitSchema, MathUnparsed, MathUnparsedSchema, SI_BASE_DIMENSIONS, SiBaseDimension, SymbolTable, SymbolTableSchema, isMathExpression };

package/dist/math.d.ts

@@ -0,0 +1,2 @@
+import { A as MathUncertaintySchema, C as MathSum, D as MathSymbolEntry, E as MathSymSchema, F as SI_BASE_DIMENSIONS, I as SiBaseDimension, L as SymbolTable, M as MathUnitSchema, N as MathUnparsed, O as MathSymbolEntrySchema, P as MathUnparsedSchema, R as SymbolTableSchema, S as MathQtySchema, T as MathSym, _ as MathProd, a as MathApp, b as MathProvenanceSchema, c as MathExpressionSchema, d as MathNormalisationContext, f as MathNormalisationContextSchema, g as MathPresentationSchema, h as MathPresentation, i as ExactRationalSchema, j as MathUnit, k as MathUncertainty, l as MathMatrix, m as MathNumSchema, n as DimensionVectorSchema, o as MathAppSchema, p as MathNum, r as ExactRational, s as MathExpression, t as DimensionVector, u as MathMatrixSchema, v as MathProdSchema, w as MathSumSchema, x as MathQty, y as MathProvenance, z as isMathExpression } from "./math-B7gZJeND.js";
+export { DimensionVector, DimensionVectorSchema, ExactRational, ExactRationalSchema, MathApp, MathAppSchema, MathExpression, MathExpressionSchema, MathMatrix, MathMatrixSchema, MathNormalisationContext, MathNormalisationContextSchema, MathNum, MathNumSchema, MathPresentation, MathPresentationSchema, MathProd, MathProdSchema, MathProvenance, MathProvenanceSchema, MathQty, MathQtySchema, MathSum, MathSumSchema, MathSym, MathSymSchema, MathSymbolEntry, MathSymbolEntrySchema, MathUncertainty, MathUncertaintySchema, MathUnit, MathUnitSchema, MathUnparsed, MathUnparsedSchema, SI_BASE_DIMENSIONS, SiBaseDimension, SymbolTable, SymbolTableSchema, isMathExpression };