@murumets-ee/imports 0.0.0-preview-20261014110621

package/dist/engine-tkbUXKxB.d.mts

@@ -0,0 +1,609 @@
+import { i as RowTransform, r as RowResult } from "./transform-WeiiLdYP.mjs";
+import { z } from "zod";
+
+//#region src/mapping/number-format.d.ts
+/**
+ * Number parsing for the configurable mapping engine (commerce-demo phase 02).
+ *
+ * Real supplier feeds (R03) disagree on decimal AND thousands separators:
+ * `55.02` (dot decimal), `326,88` (comma decimal), `1.234,56` (EU
+ * thousands+decimal), `1,234.56` (US), `1 234,56` (space-grouped). The mapping
+ * stores an explicit `{ decimal, thousands }` per profile so there is no guessing
+ * — `parseNumber` trusts the configured format.
+ *
+ * Two parsers live here:
+ *  - `parseNumber(raw, format)` — the format-driven parser used by the generic
+ *    `number` per-column transform.
+ *  - `parseEuropeanNumber(raw)` — the carmaker-feed legacy parser (comma decimal,
+ *    dot thousands, **bare-dot rejected as ambiguous**). Carries the carmaker feed's
+ *    documented format with two intentional broadenings vs the old inline parser:
+ *    it trims surrounding whitespace, and returns `null` (not `NaN`) for an empty /
+ *    `'NA'` cell so both number ops share absent-vs-malformed semantics. The
+ *    carmaker doc-shape suite (27 tests) is the regression net.
+ */
+/** Separator config for {@link parseNumber}. Stored per `import_mapping`. */
+interface NumberFormat {
+  /** Decimal separator. */
+  decimal: '.' | ',';
+  /** Thousands grouping separator. `''` = none. */
+  thousands: '' | '.' | ',' | ' ';
+}
+/**
+ * Parse a feed cell into a number using an EXPLICIT `{ decimal, thousands }`
+ * format. No ambiguity: thousands separators are stripped, the decimal separator
+ * is normalised to `.`, and the result is strict-validated.
+ *
+ * Returns:
+ *  - `null` for an empty / `'NA'` cell (a legitimately-absent value — the caller
+ *    decides whether that's allowed for a given target field).
+ *  - `NaN` for a non-empty but unparseable cell (malformed — the caller surfaces
+ *    a row-level error rather than coercing to 0).
+ *  - the parsed number otherwise.
+ *
+ * A character that is neither a digit, the configured decimal, the configured
+ * thousands separator, nor a leading `-` makes the cell unparseable (`NaN`) —
+ * e.g. a literal `.` when the format's decimal is `,` and thousands is not `.`.
+ */
+declare function parseNumber(raw: string, format: NumberFormat): number | null;
+/**
+ * Convert a major-unit money value (e.g. `55.02` EUR) to integer MINOR units
+ * (`5502`). Rounds to the nearest cent to absorb float drift. The commerce-demo
+ * PartsDocument money fields (`list_price_minor`, `purchase_price_minor`,
+ * `core_charge_minor`) are integer minor units so derived prices (PR4) don't
+ * accrue rounding error — see F003 in progress.md.
+ */
+declare function toMinorUnits(value: number): number;
+/**
+ * Parse a European-formatted decimal: `,` is the decimal separator, `.` is the
+ * (optional) thousands separator. Returns `null` for an empty / `'NA'` cell and
+ * `NaN` on unparseable (malformed) input.
+ *
+ * This is the carmaker-feed legacy parser, preserved from the hardcoded transform.
+ * Crucially it **rejects bare-dot** input (`1.98`, `1.234`) as ambiguous rather
+ * than guessing — the carmaker feeds are documented as comma-decimal, and a `.`
+ * without a `,` could mean a US-format decimal OR a thousands marker. The
+ * format-driven {@link parseNumber} doesn't need this guard (its separators are
+ * explicit); the carmaker path keeps it.
+ *
+ * The `null` (absent) vs `NaN` (malformed) split mirrors {@link parseNumber} so
+ * the mapping engine treats both number ops uniformly: a target field's `buildRow`
+ * reads `null` as "not provided" and `NaN` as "invalid". This is what lets the
+ * reimplemented carmaker transform keep its `GrossPrice 'NA' → null` behaviour
+ * (optional field) while still erroring on a malformed `NetPrice` (required).
+ *
+ * Cases: `'1,98'`→`1.98`, `'1.234,56'`→`1234.56`, `'5'`→`5`, `'-5,00'`→`-5`,
+ * empty / `'NA'` → `null`. Rejected (`NaN`): bare-dot (`'1.98'`, `'1.234'`),
+ * trailing junk (`'1,98EUR'`), multiple commas (`'1,2,3'`), other non-numeric.
+ */
+declare function parseEuropeanNumber(s: string): number | null;
+//#endregion
+//#region src/mapping/column-transforms.d.ts
+/**
+ * Discriminated union of bounded transform ops. The TS type is INFERRED from
+ * this schema so there's a single source of truth + the snapshot is validated at
+ * the engine boundary.
+ */
+declare const columnTransformSchema: z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+  op: z.ZodLiteral<"trim">;
+}, "strip", z.ZodTypeAny, {
+  op: "trim";
+}, {
+  op: "trim";
+}>, z.ZodObject<{
+  op: z.ZodLiteral<"uppercase">;
+}, "strip", z.ZodTypeAny, {
+  op: "uppercase";
+}, {
+  op: "uppercase";
+}>, z.ZodObject<{
+  op: z.ZodLiteral<"lowercase">;
+}, "strip", z.ZodTypeAny, {
+  op: "lowercase";
+}, {
+  op: "lowercase";
+}>, z.ZodObject<{
+  op: z.ZodLiteral<"stripPrefix">;
+  value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  value: string;
+  op: "stripPrefix";
+}, {
+  value: string;
+  op: "stripPrefix";
+}>, z.ZodObject<{
+  op: z.ZodLiteral<"stripSuffix">;
+  value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  value: string;
+  op: "stripSuffix";
+}, {
+  value: string;
+  op: "stripSuffix";
+}>, z.ZodObject<{
+  op: z.ZodLiteral<"defaultIfEmpty">;
+  value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+  value: string;
+  op: "defaultIfEmpty";
+}, {
+  value: string;
+  op: "defaultIfEmpty";
+}>, z.ZodObject<{
+  op: z.ZodLiteral<"number">;
+}, "strip", z.ZodTypeAny, {
+  op: "number";
+}, {
+  op: "number";
+}>, z.ZodObject<{
+  op: z.ZodLiteral<"europeanNumber">;
+}, "strip", z.ZodTypeAny, {
+  op: "europeanNumber";
+}, {
+  op: "europeanNumber";
+}>]>;
+/** One declarative cleaning operation. */
+type ColumnTransform = z.infer<typeof columnTransformSchema>;
+/** The discriminator literal of a {@link ColumnTransform}. */
+type ColumnTransformOp = ColumnTransform['op'];
+/** UI descriptor for one transform op: its key, a label, and whether it takes a `value` param. */
+interface ColumnTransformOpDescriptor {
+  op: ColumnTransformOp;
+  label: string;
+  /** `true` → the op carries a `value` string param (`stripPrefix`/`stripSuffix`/`defaultIfEmpty`). */
+  hasValue: boolean;
+}
+/**
+ * Static catalogue of the available per-column transform ops, for the PR3 wizard's
+ * transform picker. The ORDER is the suggested UI order; `number`/`europeanNumber`
+ * are terminal (see {@link applyColumnTransforms}) and labelled accordingly.
+ */
+declare const COLUMN_TRANSFORM_OPS: readonly ColumnTransformOpDescriptor[];
+/** The value a column carries as it moves through the transform pipeline. */
+type CellValue = string | number | null;
+/**
+ * Apply a transform pipeline to a raw cell, left-to-right. String ops act on the
+ * string value; the `number` / `europeanNumber` ops are terminal (convert to
+ * `number | null`, with `NaN` for a malformed numeric — the schema's `buildRow`
+ * surfaces that as a row error). Once the value is non-string, later string ops
+ * pass through unchanged.
+ */
+declare function applyColumnTransforms(raw: string, transforms: readonly ColumnTransform[], format: NumberFormat): CellValue;
+//#endregion
+//#region src/mapping/target-schema.d.ts
+/** One whitelisted target field on a schema. */
+interface TargetField {
+  /** Stable target key referenced by `column_map[].target`. */
+  key: string;
+  /** Human label for the wizard dropdown (PR3). */
+  label: string;
+  /** Whether a mapping for this schema MUST include this target. */
+  required: boolean;
+  /** Coarse type — drives the wizard's transform suggestions; `buildRow` does the real coercion. */
+  type: 'string' | 'number';
+  /**
+   * Header spellings this field should be SUGGESTED for when the wizard auto-assigns a freshly
+   * previewed file. Purely advisory: the operator can always override, and nothing here widens
+   * the injection-boundary whitelist — `key` remains the only accepted `column_map[].target`.
+   *
+   * Real feeds do not name their columns after our keys (a supplier ships `partno`, `VARUOSA
+   * KOOD`, `ArticleName`, never `code`), so without aliases the wizard suggests nothing for the
+   * columns that matter and the operator has to know the schema by heart. `describeTargetSchemas`
+   * ships this to the wizard verbatim, so a field's synonyms live next to the field itself
+   * rather than in a lookup table on the client.
+   *
+   * Only add a spelling whose meaning is UNAMBIGUOUS. An alias is a silent decision applied to
+   * somebody's catalogue — see the supersession fields below, where two spellings that both read
+   * as "replacement" denote opposite directions and are therefore deliberately absent.
+   */
+  aliases?: readonly string[];
+}
+/** The per-row product of the engine: target field key → cleaned value. */
+type MappedRow = Record<string, CellValue>;
+/** Per-row context handed to `buildRow`. `params` is the opaque per-run params object. */
+interface BuildRowContext {
+  importRunId: string;
+  rowNumber: number;
+  /**
+   * Opaque per-run params (the parts schema reads brand/supplier identity from
+   * it; `discount_table` ignores it). The schema validates the shape it needs.
+   */
+  params: Record<string, unknown>;
+}
+/** A registered target schema: a whitelist + a row builder. */
+interface TargetSchema<TOut> {
+  /** Registered name — also the `import_mapping.target_schema` value. */
+  name: string;
+  /** The target-field whitelist (injection boundary). */
+  fields: readonly TargetField[];
+  /** Build a typed output (success) / skip / error from a mapped row. */
+  buildRow(mapped: MappedRow, ctx: BuildRowContext): RowResult<TOut>;
+}
+/**
+ * A nullable text cell → trimmed string, or `null` for empty / non-string. Accepts
+ * `undefined` (an UNMAPPED target — indexed access under `noUncheckedIndexedAccess`)
+ * and treats it as absent.
+ */
+declare function textOrNull(v: CellValue | undefined): string | null;
+/** The three outcomes a `number` / `europeanNumber` op produces for a cell. */
+type NumberOutcome = {
+  kind: 'value';
+  value: number;
+} | {
+  kind: 'absent';
+} | {
+  kind: 'invalid';
+};
+/**
+ * Classify a cell that should hold a number. `undefined` (unmapped) / `null` →
+ * absent; a real number → value (`NaN` → invalid); a non-empty raw string (no
+ * number op declared) → invalid; a blank raw string → absent.
+ */
+declare function numberCell(v: CellValue | undefined): NumberOutcome;
+/** Build a `RowResult` error variant (assignable to any `TargetSchema<TOut>`). */
+declare function rowError(errorType: string, message: string, field: string): {
+  kind: "error";
+  error: {
+    errorType: string;
+    message: string;
+    field: string;
+  };
+};
+//#endregion
+//#region src/mapping/engine.d.ts
+/** One column-map entry. `target` is checked against the schema whitelist separately. */
+declare const mappingColumnSchema: z.ZodObject<{
+  /** Source header name (or positional index string for headerless feeds). */source: z.ZodString; /** Target field key — must be in the chosen schema's whitelist (enforced in `buildMappingTransform`). */
+  target: z.ZodString; /** Ordered per-column cleaning ops. Defaults to none. */
+  transforms: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+    op: z.ZodLiteral<"trim">;
+  }, "strip", z.ZodTypeAny, {
+    op: "trim";
+  }, {
+    op: "trim";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"uppercase">;
+  }, "strip", z.ZodTypeAny, {
+    op: "uppercase";
+  }, {
+    op: "uppercase";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"lowercase">;
+  }, "strip", z.ZodTypeAny, {
+    op: "lowercase";
+  }, {
+    op: "lowercase";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"stripPrefix">;
+    value: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    value: string;
+    op: "stripPrefix";
+  }, {
+    value: string;
+    op: "stripPrefix";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"stripSuffix">;
+    value: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    value: string;
+    op: "stripSuffix";
+  }, {
+    value: string;
+    op: "stripSuffix";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"defaultIfEmpty">;
+    value: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    value: string;
+    op: "defaultIfEmpty";
+  }, {
+    value: string;
+    op: "defaultIfEmpty";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"number">;
+  }, "strip", z.ZodTypeAny, {
+    op: "number";
+  }, {
+    op: "number";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"europeanNumber">;
+  }, "strip", z.ZodTypeAny, {
+    op: "europeanNumber";
+  }, {
+    op: "europeanNumber";
+  }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+  target: string;
+  transforms: ({
+    op: "trim";
+  } | {
+    op: "uppercase";
+  } | {
+    op: "lowercase";
+  } | {
+    value: string;
+    op: "stripPrefix";
+  } | {
+    value: string;
+    op: "stripSuffix";
+  } | {
+    value: string;
+    op: "defaultIfEmpty";
+  } | {
+    op: "number";
+  } | {
+    op: "europeanNumber";
+  })[];
+  source: string;
+}, {
+  target: string;
+  source: string;
+  transforms?: ({
+    op: "trim";
+  } | {
+    op: "uppercase";
+  } | {
+    op: "lowercase";
+  } | {
+    value: string;
+    op: "stripPrefix";
+  } | {
+    value: string;
+    op: "stripSuffix";
+  } | {
+    value: string;
+    op: "defaultIfEmpty";
+  } | {
+    op: "number";
+  } | {
+    op: "europeanNumber";
+  })[] | undefined;
+}>;
+type MappingColumn = z.infer<typeof mappingColumnSchema>;
+/**
+ * Decimal + thousands separators for the `number` transform.
+ *
+ * The two MUST differ: `parseNumber` strips every thousands separator FIRST, so a
+ * config where `decimal === thousands` (e.g. both `,`) would strip the decimal
+ * separator too — `326,88` → `32688`, a silent 100× error rather than a row error.
+ * Rejected at save (`assertValidMapping`) AND at run (`mappingConfigSchema`).
+ */
+declare const numberFormatSchema: z.ZodEffects<z.ZodObject<{
+  decimal: z.ZodEnum<[".", ","]>;
+  thousands: z.ZodEnum<["", ".", ",", " "]>;
+}, "strip", z.ZodTypeAny, {
+  decimal: "," | ".";
+  thousands: "" | "," | "." | " ";
+}, {
+  decimal: "," | ".";
+  thousands: "" | "," | "." | " ";
+}>, {
+  decimal: "," | ".";
+  thousands: "" | "," | "." | " ";
+}, {
+  decimal: "," | ".";
+  thousands: "" | "," | "." | " ";
+}>;
+/**
+ * The portable mapping config — the subset of an `import_mapping` row the engine
+ * needs. The enqueuer SNAPSHOTS this into `import_run.params.mapping` so a run
+ * records the exact mapping it used (reproducible) and the transform stays a pure
+ * function of `(row, ctx)` with no per-row DB I/O.
+ */
+declare const mappingConfigSchema: z.ZodObject<{
+  targetSchema: z.ZodString;
+  numberFormat: z.ZodEffects<z.ZodObject<{
+    decimal: z.ZodEnum<[".", ","]>;
+    thousands: z.ZodEnum<["", ".", ",", " "]>;
+  }, "strip", z.ZodTypeAny, {
+    decimal: "," | ".";
+    thousands: "" | "," | "." | " ";
+  }, {
+    decimal: "," | ".";
+    thousands: "" | "," | "." | " ";
+  }>, {
+    decimal: "," | ".";
+    thousands: "" | "," | "." | " ";
+  }, {
+    decimal: "," | ".";
+    thousands: "" | "," | "." | " ";
+  }>;
+  columnMap: z.ZodArray<z.ZodObject<{
+    /** Source header name (or positional index string for headerless feeds). */source: z.ZodString; /** Target field key — must be in the chosen schema's whitelist (enforced in `buildMappingTransform`). */
+    target: z.ZodString; /** Ordered per-column cleaning ops. Defaults to none. */
+    transforms: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+      op: z.ZodLiteral<"trim">;
+    }, "strip", z.ZodTypeAny, {
+      op: "trim";
+    }, {
+      op: "trim";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"uppercase">;
+    }, "strip", z.ZodTypeAny, {
+      op: "uppercase";
+    }, {
+      op: "uppercase";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"lowercase">;
+    }, "strip", z.ZodTypeAny, {
+      op: "lowercase";
+    }, {
+      op: "lowercase";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"stripPrefix">;
+      value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      op: "stripPrefix";
+    }, {
+      value: string;
+      op: "stripPrefix";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"stripSuffix">;
+      value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      op: "stripSuffix";
+    }, {
+      value: string;
+      op: "stripSuffix";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"defaultIfEmpty">;
+      value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      op: "defaultIfEmpty";
+    }, {
+      value: string;
+      op: "defaultIfEmpty";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"number">;
+    }, "strip", z.ZodTypeAny, {
+      op: "number";
+    }, {
+      op: "number";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"europeanNumber">;
+    }, "strip", z.ZodTypeAny, {
+      op: "europeanNumber";
+    }, {
+      op: "europeanNumber";
+    }>]>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    target: string;
+    transforms: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[];
+    source: string;
+  }, {
+    target: string;
+    source: string;
+    transforms?: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[] | undefined;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  targetSchema: string;
+  numberFormat: {
+    decimal: "," | ".";
+    thousands: "" | "," | "." | " ";
+  };
+  columnMap: {
+    target: string;
+    transforms: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[];
+    source: string;
+  }[];
+}, {
+  targetSchema: string;
+  numberFormat: {
+    decimal: "," | ".";
+    thousands: "" | "," | "." | " ";
+  };
+  columnMap: {
+    target: string;
+    source: string;
+    transforms?: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[] | undefined;
+  }[];
+}>;
+type MappingConfig = z.infer<typeof mappingConfigSchema>;
+/**
+ * Build a `RowTransform` from a validated mapping config + its target schema.
+ *
+ * Throws at BUILD time if any `column_map` target is outside the schema's
+ * whitelist (deny-by-default, R02) — so a misconfigured mapping fails loudly
+ * before a single row is written, rather than silently dropping a column.
+ *
+ * Generic over the schema's output type, so passing the concrete `partsSchema`
+ * yields a `RowTransform<PartsDocument>` (the carmaker path keeps its typing); the
+ * registry-resolved `TargetSchema<unknown>` yields `RowTransform<unknown>` (the
+ * `commerce:mapping` path, where the output type isn't known until runtime).
+ */
+declare function buildMappingTransform<TOut>(config: MappingConfig, schema: TargetSchema<TOut>): RowTransform<TOut>;
+/** The minimal shape `resolveMapping` needs — satisfied by an `import_mapping` row or a test fixture. */
+interface ResolvableMapping {
+  /** `null` = supplier default (applies to all brands). */
+  brandId: string | null;
+  active: boolean;
+}
+/**
+ * Most-specific resolution (D002 ladder): given the candidate mappings for one
+ * `(supplier, target_schema)` and the requested brand, return the brand-specific
+ * mapping if one exists, else the supplier-default (`brandId === null`). Inactive
+ * mappings are skipped. Returns `undefined` when nothing matches.
+ */
+declare function resolveMapping<M extends ResolvableMapping>(mappings: readonly M[], brandId: string | null): M | undefined;
+//#endregion
+export { columnTransformSchema as C, toMinorUnits as D, parseNumber as E, applyColumnTransforms as S, parseEuropeanNumber as T, COLUMN_TRANSFORM_OPS as _, mappingColumnSchema as a, ColumnTransformOp as b, resolveMapping as c, NumberOutcome as d, TargetField as f, textOrNull as g, rowError as h, buildMappingTransform as i, BuildRowContext as l, numberCell as m, MappingConfig as n, mappingConfigSchema as o, TargetSchema as p, ResolvableMapping as r, numberFormatSchema as s, MappingColumn as t, MappedRow as u, CellValue as v, NumberFormat as w, ColumnTransformOpDescriptor as x, ColumnTransform as y };
+//# sourceMappingURL=engine-tkbUXKxB.d.mts.map

package/dist/engine-tkbUXKxB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-tkbUXKxB.d.mts","names":[],"sources":["../src/mapping/number-format.ts","../src/mapping/column-transforms.ts","../src/mapping/target-schema.ts","../src/mapping/engine.ts"],"mappings":";;;;;;;;AAqBA;;;;AAIW;AAsBX;;;;;;;;AAA6D;AA+B7D;;UAzDiB,YAAA;EAyDyB;EAvDxC,OAAA;EAiFc;EA/Ed,SAAS;AAAA;;AA+EkC;;;;AC9E7C;;;;;;;;;;;iBDqBgB,WAAA,CAAY,GAAA,UAAa,MAAA,EAAQ,YAAY;;;;;;;;iBA+B7C,YAAA,CAAa,KAAa;;;;;;;;;;;;;;;;;;;;;;;iBA0B1B,mBAAA,CAAoB,CAAS;;;;AAzDgB;AA+B7D;;;cCpDa,qBAAA,EAAqB,CAAA,CAAA,qBAAA,QAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAYtB,eAAA,GAAkB,CAAA,CAAE,KAAK,QAAQ,qBAAA;;KAGjC,iBAAA,GAAoB,eAAe;;UAG9B,2BAAA;EACf,EAAA,EAAI,iBAAiB;EACrB,KAAA;;EAEA,QAAA;AAAA;;;;;;cAQW,oBAAA,WAA+B,2BAA2B;;KAY3D,SAAA;;;;;;;;iBASI,qBAAA,CACd,GAAA,UACA,UAAA,WAAqB,eAAA,IACrB,MAAA,EAAQ,YAAA,GACP,SAAA;;;;UC/Dc,WAAA;EF6B4C;EE3B3D,GAAA;EF0D0B;EExD1B,KAAA;EFwDwC;EEtDxC,QAAA;EFgFc;EE9Ed,IAAA;;;AF8E2C;;;;AC9E7C;;;;;;;;;ECgBE,OAAA;AAAA;;KAIU,SAAA,GAAY,MAAM,SAAS,SAAA;;UAGtB,eAAA;EACf,WAAA;EACA,SAAA;;;;;EAKA,MAAA,EAAQ,MAAM;AAAA;;UAIC,YAAA;;EAEf,IAAA;;EAEA,MAAA,WAAiB,WAAA;;EAEjB,QAAA,CAAS,MAAA,EAAQ,SAAA,EAAW,GAAA,EAAK,eAAA,GAAkB,SAAA,CAAU,IAAA;AAAA;;;;;;iBAY/C,UAAA,CAAW,CAAwB,EAArB,SAAS;;KAO3B,aAAA;EACN,IAAA;EAAe,KAAA;AAAA;EACf,IAAA;AAAA;EACA,IAAA;AAAA;;;;;;iBAOU,UAAA,CAAW,CAAA,EAAG,SAAA,eAAwB,aAAa;;iBASnD,QAAA,CAAS,SAAA,UAAmB,OAAA,UAAiB,KAAA;;;;;;;;;;;cChFhD,mBAAA,EAAmB,CAAA,CAAA,SAAA;EHsDU,iGA0BP;uBAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KGxEjC,aAAA,GAAgB,CAAA,CAAE,KAAK,QAAQ,mBAAA;;;;;;;;;cAU9B,kBAAA,EAAkB,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;cAgBlB,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;IFFuC,iGAY3D;yBAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KELT,aAAA,GAAgB,CAAA,CAAE,KAAK,QAAQ,mBAAA;;;;;;;;;;;;;iBAc3B,qBAAA,OACd,MAAA,EAAQ,aAAA,EACR,MAAA,EAAQ,YAAA,CAAa,IAAA,IACpB,YAAA,CAAa,IAAA;;UA+BC,iBAAA;;EAEf,OAAA;EACA,MAAM;AAAA;;;;;;;iBASQ,cAAA,WAAyB,iBAAA,EACvC,QAAA,WAAmB,CAAA,IACnB,OAAA,kBACC,CAAA"}