@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/mwl/MapFile.d.ts

@@ -1,41 +0,0 @@
-/**
- * A loaded `.map`: the header keys the file declared, the grid `parseTerrain` already produces,
- * and the same start markers an inline `[map] terrain=` string carries.
- */
-export interface MwlMapFile {
-    /** the `key=value` lines before the grid, in the order written (`border_size`, `usage`, ...) */
-    readonly header: Readonly<Record<string, string>>;
-    readonly width: number;
-    readonly height: number;
-    /** row-major terrain codes, `width * height` of them */
-    readonly codes: string[];
-    /** side number -> the hexes its `[side] start` came from, when the grid marks them */
-    readonly starts: Record<number, {
-        x: number;
-        y: number;
-    }[]>;
-}
-/**
- * Reads a Wesnoth-shaped `.map` file: `key=value` header lines (`border_size=1`, `usage=map`,
- * and anything else the file carries), then one comma-separated row of terrain codes per line.
- * The header is split off and kept, and the grid goes through the same `parseTerrain` an inline
- * `[map] terrain=` string does, so a cell is `base^overlay` exactly as it is there and a
- * `<side> <code>` token still marks that side's start.
- *
- * A file with no header is a bare grid, and the header keys are not interpreted here: what
- * `usage` or `border_size` means to a game is the game's business, the same way this framework
- * leaves `[terrain_graphics]` rules to content.
- *
- * @example
- * ```ts
- * import { parseMapFile } from '@datamoc/mw_games/mwl';
- *
- * const map = parseMapFile('border_size=1\nusage=map\n\nGg, Gg, Gg\nGg, Gg^Vh, Gg\n');
- * map.header.usage; // 'map'
- * map.width; // 3
- * map.height; // 2
- * map.codes; // ['Gg', 'Gg', 'Gg', 'Gg', 'Gg^Vh', 'Gg'] - overlays kept as written
- * ```
- */
-export declare function parseMapFile(text: string): MwlMapFile;
-//# sourceMappingURL=MapFile.d.ts.map

package/dist/mwl/MapFile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MapFile.d.ts","sourceRoot":"","sources":["../../src/mwl/MapFile.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,UAAU;IAC1B,gGAAgG;IAChG,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IACzB,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAC;CAC5D;AAID;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAiBrD"}

package/dist/mwl/MapFile.js

@@ -1,53 +0,0 @@
-import { parseTerrain } from './runtime.js';
-const HEADER_LINE = /^\s*([A-Za-z_][\w]*)\s*=\s*(.*?)\s*$/;
-/**
- * Reads a Wesnoth-shaped `.map` file: `key=value` header lines (`border_size=1`, `usage=map`,
- * and anything else the file carries), then one comma-separated row of terrain codes per line.
- * The header is split off and kept, and the grid goes through the same `parseTerrain` an inline
- * `[map] terrain=` string does, so a cell is `base^overlay` exactly as it is there and a
- * `<side> <code>` token still marks that side's start.
- *
- * A file with no header is a bare grid, and the header keys are not interpreted here: what
- * `usage` or `border_size` means to a game is the game's business, the same way this framework
- * leaves `[terrain_graphics]` rules to content.
- *
- * @example
- * ```ts
- * import { parseMapFile } from '@datamoc/mw_games/mwl';
- *
- * const map = parseMapFile('border_size=1\nusage=map\n\nGg, Gg, Gg\nGg, Gg^Vh, Gg\n');
- * map.header.usage; // 'map'
- * map.width; // 3
- * map.height; // 2
- * map.codes; // ['Gg', 'Gg', 'Gg', 'Gg', 'Gg^Vh', 'Gg'] - overlays kept as written
- * ```
- */
-export function parseMapFile(text) {
-    const lines = text.split(/\r?\n/);
-    const header = {};
-    let index = 0;
-    for (; index < lines.length; index++) {
-        const line = lines[index];
-        if (line.trim() === '')
-            continue;
-        const match = HEADER_LINE.exec(line);
-        if (!match)
-            break;
-        header[match[1]] = match[2];
-    }
-    //a trailing separator or stray spaces would otherwise become an empty cell
-    const grid = lines.slice(index).map(trimSeparators);
-    const parsed = parseTerrain(grid.join('\n'));
-    return { header, ...parsed };
-}
-/**
- * `line` without its trailing commas and whitespace. A scan from the end rather than
- * `/[,\s]+$/`, which backtracks quadratically: a line of 28 000 spaces took a second.
- */
-function trimSeparators(line) {
-    let end = line.length;
-    while (end > 0 && (line[end - 1] === ',' || /\s/.test(line[end - 1])))
-        end--;
-    return line.slice(0, end);
-}
-//# sourceMappingURL=MapFile.js.map

package/dist/mwl/MapFile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"MapFile.js","sourceRoot":"","sources":["../../src/mwl/MapFile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAiB5C,MAAM,WAAW,GAAG,sCAAsC,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,YAAY,CAAC,IAAY;IACxC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAElC,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,OAAO,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;YAAE,SAAS;QACjC,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,KAAK;YAAE,MAAM;QAClB,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAC7B,CAAC;IAED,2EAA2E;IAC3E,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACpD,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AAC9B,CAAC;AAED;;;GAGG;AACH,SAAS,cAAc,CAAC,IAAY;IACnC,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC;IACtB,OAAO,GAAG,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QAAE,GAAG,EAAE,CAAC;IAC7E,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC3B,CAAC"}

package/dist/mwl/actors.d.ts

@@ -1,62 +0,0 @@
-import type { EquipmentSlots } from '../actors/Equipment.ts';
-import type { InventoryItem, ItemDefinition } from '../actors/Inventory.ts';
-import { type Modifier } from '../actors/StatBlock.ts';
-import type { MwlEffectDefinition, MwlItemDefinition } from './content.ts';
-import { type MwlExpressionContext } from './expression.ts';
-export interface MwlActorItem extends ItemDefinition {
-    readonly id: string;
-    readonly slot?: string;
-    readonly modifiers?: Modifier[];
-}
-/**
- * Converts MWL's data shape into the actor layer without importing game rules.
- *
- * @example
- * ```ts
- * import { itemDefinition, type MwlItemDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const item: MwlItemDefinition;
- * const actorItem = itemDefinition(item, { level: 2 });
- * console.log(actorItem.id);
- * ```
- */
-export declare function itemDefinition(item: MwlItemDefinition, context?: MwlExpressionContext): MwlActorItem;
-/**
- * Wraps a converted item as an inventory stack of `quantity`.
- *
- * @example
- * ```ts
- * import { inventoryItem, itemDefinition, type MwlItemDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const item: MwlItemDefinition;
- * const stack = inventoryItem(itemDefinition(item), 3);
- * console.log(stack.quantity); // 3
- * ```
- */
-export declare function inventoryItem(item: MwlActorItem, quantity?: number): InventoryItem;
-/**
- * Resolve a declarative MWL effect list using the same rule as StatBlock.
- *
- * @example
- * ```ts
- * import { composeEffects, type MwlEffectDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const effects: readonly MwlEffectDefinition[];
- * console.log(composeEffects(10, effects, { level: 2 }));
- * ```
- */
-export declare function composeEffects(base: number, effects: readonly MwlEffectDefinition[], context?: MwlExpressionContext): number;
-/**
- * Converts one MWL effect into a `StatBlock` modifier, resolving its value expression.
- *
- * @example
- * ```ts
- * import { effectToModifier, type MwlEffectDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const effect: MwlEffectDefinition;
- * console.log(effectToModifier(effect, { level: 2 }));
- * ```
- */
-export declare function effectToModifier(effect: MwlEffectDefinition, context?: MwlExpressionContext): Modifier;
-export type MwlEquipment<Slot extends string> = EquipmentSlots<Slot, MwlActorItem>;
-//# sourceMappingURL=actors.d.ts.map

package/dist/mwl/actors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"actors.d.ts","sourceRoot":"","sources":["../../src/mwl/actors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,EAAoB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEhF,MAAM,WAAW,YAAa,SAAQ,cAAc;IACnD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,GAAE,oBAAyB,GAAG,YAAY,CAQxG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,SAAI,GAAG,aAAa,CAE7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,OAAO,GAAE,oBAAyB,GAChC,MAAM,CAKR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,GAAE,oBAAyB,GAAG,QAAQ,CAkB1G;AAED,MAAM,MAAM,YAAY,CAAC,IAAI,SAAS,MAAM,IAAI,cAAc,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC"}

package/dist/mwl/actors.js

@@ -1,82 +0,0 @@
-import { composeModifiers } from '../actors/StatBlock.js';
-import { evaluateExpression } from './expression.js';
-/**
- * Converts MWL's data shape into the actor layer without importing game rules.
- *
- * @example
- * ```ts
- * import { itemDefinition, type MwlItemDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const item: MwlItemDefinition;
- * const actorItem = itemDefinition(item, { level: 2 });
- * console.log(actorItem.id);
- * ```
- */
-export function itemDefinition(item, context = {}) {
-    return {
-        id: item.id,
-        stackable: item.stackable,
-        weight: item.weight,
-        slot: item.slot,
-        modifiers: item.effects.map((effect) => effectToModifier(effect, context)),
-    };
-}
-/**
- * Wraps a converted item as an inventory stack of `quantity`.
- *
- * @example
- * ```ts
- * import { inventoryItem, itemDefinition, type MwlItemDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const item: MwlItemDefinition;
- * const stack = inventoryItem(itemDefinition(item), 3);
- * console.log(stack.quantity); // 3
- * ```
- */
-export function inventoryItem(item, quantity = 1) {
-    return { id: item.id, quantity, stackable: item.stackable, weight: item.weight };
-}
-/**
- * Resolve a declarative MWL effect list using the same rule as StatBlock.
- *
- * @example
- * ```ts
- * import { composeEffects, type MwlEffectDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const effects: readonly MwlEffectDefinition[];
- * console.log(composeEffects(10, effects, { level: 2 }));
- * ```
- */
-export function composeEffects(base, effects, context = {}) {
-    return composeModifiers(base, effects.map((effect) => effectToModifier(effect, context)));
-}
-/**
- * Converts one MWL effect into a `StatBlock` modifier, resolving its value expression.
- *
- * @example
- * ```ts
- * import { effectToModifier, type MwlEffectDefinition } from '@datamoc/mw_games/mwl';
- *
- * declare const effect: MwlEffectDefinition;
- * console.log(effectToModifier(effect, { level: 2 }));
- * ```
- */
-export function effectToModifier(effect, context = {}) {
-    const operation = effect.operation;
-    if (operation !== 'add' &&
-        operation !== 'sub' &&
-        operation !== 'multiply' &&
-        operation !== 'divide' &&
-        operation !== 'set')
-        throw new Error(`MWL effect operation "${operation ?? ''}" is not a StatBlock modifier`);
-    const raw = effect.value;
-    if (raw === undefined)
-        throw new Error('MWL effect has no value');
-    const value = evaluateExpression(raw, context);
-    return {
-        stat: effect.applyTo,
-        op: operation === 'sub' ? 'add' : operation === 'divide' ? 'multiply' : operation,
-        value: operation === 'sub' ? -value : operation === 'divide' ? 1 / value : value,
-    };
-}
-//# sourceMappingURL=actors.js.map

package/dist/mwl/actors.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actors.js","sourceRoot":"","sources":["../../src/mwl/actors.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAiB,MAAM,wBAAwB,CAAC;AAEzE,OAAO,EAAE,kBAAkB,EAA6B,MAAM,iBAAiB,CAAC;AAQhF;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,IAAuB,EAAE,OAAO,GAAyB,EAAE;IACzF,OAAO;QACN,EAAE,EAAE,IAAI,CAAC,EAAE;QACX,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,IAAI,EAAE,IAAI,CAAC,IAAI;QACf,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC1E,CAAC;AACH,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAC,IAAkB,EAAE,QAAQ,GAAG,CAAC;IAC7D,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC;AAClF,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAC7B,IAAY,EACZ,OAAuC,EACvC,OAAO,GAAyB,EAAE;IAElC,OAAO,gBAAgB,CACtB,IAAI,EACJ,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAC1D,CAAC;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAA2B,EAAE,OAAO,GAAyB,EAAE;IAC/F,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IACnC,IACC,SAAS,KAAK,KAAK;QACnB,SAAS,KAAK,KAAK;QACnB,SAAS,KAAK,UAAU;QACxB,SAAS,KAAK,QAAQ;QACtB,SAAS,KAAK,KAAK;QAEnB,MAAM,IAAI,KAAK,CAAC,yBAAyB,SAAS,IAAI,EAAE,+BAA+B,CAAC,CAAC;IAC1F,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC;IACzB,IAAI,GAAG,KAAK,SAAS;QAAE,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAClE,MAAM,KAAK,GAAG,kBAAkB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC/C,OAAO;QACN,IAAI,EAAE,MAAM,CAAC,OAAO;QACpB,EAAE,EAAE,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS;QACjF,KAAK,EAAE,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,KAAK;KAChF,CAAC;AACH,CAAC"}

package/dist/mwl/campaign.d.ts

@@ -1,51 +0,0 @@
-import type { StateValue } from '../core/State.ts';
-import type { CampaignLevel, CampaignLevelResult } from '../simulation/Campaign.ts';
-import type { MwlCampaignDefinition, MwlScenarioLink } from './content.ts';
-/** What playing one scenario means, which only the game can say. */
-export type MwlScenarioRunner<State extends StateValue, Result extends StateValue = StateValue> = (scenario: MwlScenarioLink, state: State, context: {
-    readonly levelId: string;
-}) => CampaignLevelResult<State, Result>;
-/** A campaign's chain, shaped for `simulation.Campaign`: where it opens, and one level per scenario. */
-export interface MwlCampaignChain<State extends StateValue, Result extends StateValue = StateValue> {
-    readonly start: string;
-    readonly levels: readonly CampaignLevel<State, Result>[];
-}
-/**
- * Points a `[campaign]` at `simulation.Campaign`: the order comes out of the content, the playing
- * stays the game's.
- *
- * `first_scenario` opens the campaign, and the first declared scenario opens it when the attribute
- * is not set. Each scenario's `next_scenario` is where it goes when it is won, and a scenario that
- * ends the chain leaves it: the campaign finishes. A scenario that decides for itself keeps its
- * decision, because a result carrying `next` is passed through untouched - which is exactly what a
- * runtime `[endlevel]` does when it overrides the authored chain.
- *
- * Malformed chains throw by name rather than being guessed at: no scenarios, the same id twice, or
- * a `first_scenario` naming something the campaign does not have.
- *
- * @example
- * ```ts
- * import { campaignChain } from '@datamoc/mw_games/mwl';
- * import { Campaign } from '@datamoc/mw_games/simulation';
- *
- * const definition = {
- *   id: 'prologue',
- *   firstScenario: 'opening',
- *   scenarios: [{ id: 'opening', nextScenario: 'siege' }, { id: 'siege' }],
- * };
- *
- * const chain = campaignChain(definition, {
- *   run: (scenario, state) => ({ outcome: 'completed', state, result: scenario.id }),
- * });
- *
- * const campaign = new Campaign({ levels: chain.levels, start: chain.start, state: { gold: 100 } });
- * campaign.playCurrent();
- * console.log(campaign.currentLevel); // 'siege'
- * campaign.playCurrent();
- * console.log(campaign.currentLevel); // null - the chain is done
- * ```
- */
-export declare function campaignChain<State extends StateValue, Result extends StateValue = StateValue>(definition: MwlCampaignDefinition, options: {
-    readonly run: MwlScenarioRunner<State, Result>;
-}): MwlCampaignChain<State, Result>;
-//# sourceMappingURL=campaign.d.ts.map

package/dist/mwl/campaign.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"campaign.d.ts","sourceRoot":"","sources":["../../src/mwl/campaign.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACpF,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE3E,oEAAoE;AACpE,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,UAAU,EAAE,MAAM,SAAS,UAAU,GAAG,UAAU,IAAI,CACjG,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,KACjC,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AAExC,wGAAwG;AACxG,MAAM,WAAW,gBAAgB,CAAC,KAAK,SAAS,UAAU,EAAE,MAAM,SAAS,UAAU,GAAG,UAAU;IACjG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,CAAC;CACzD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,aAAa,CAAC,KAAK,SAAS,UAAU,EAAE,MAAM,SAAS,UAAU,GAAG,UAAU,EAC7F,UAAU,EAAE,qBAAqB,EACjC,OAAO,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CAAE,GACzD,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAqBjC"}

package/dist/mwl/campaign.js

@@ -1,58 +0,0 @@
-/**
- * Points a `[campaign]` at `simulation.Campaign`: the order comes out of the content, the playing
- * stays the game's.
- *
- * `first_scenario` opens the campaign, and the first declared scenario opens it when the attribute
- * is not set. Each scenario's `next_scenario` is where it goes when it is won, and a scenario that
- * ends the chain leaves it: the campaign finishes. A scenario that decides for itself keeps its
- * decision, because a result carrying `next` is passed through untouched - which is exactly what a
- * runtime `[endlevel]` does when it overrides the authored chain.
- *
- * Malformed chains throw by name rather than being guessed at: no scenarios, the same id twice, or
- * a `first_scenario` naming something the campaign does not have.
- *
- * @example
- * ```ts
- * import { campaignChain } from '@datamoc/mw_games/mwl';
- * import { Campaign } from '@datamoc/mw_games/simulation';
- *
- * const definition = {
- *   id: 'prologue',
- *   firstScenario: 'opening',
- *   scenarios: [{ id: 'opening', nextScenario: 'siege' }, { id: 'siege' }],
- * };
- *
- * const chain = campaignChain(definition, {
- *   run: (scenario, state) => ({ outcome: 'completed', state, result: scenario.id }),
- * });
- *
- * const campaign = new Campaign({ levels: chain.levels, start: chain.start, state: { gold: 100 } });
- * campaign.playCurrent();
- * console.log(campaign.currentLevel); // 'siege'
- * campaign.playCurrent();
- * console.log(campaign.currentLevel); // null - the chain is done
- * ```
- */
-export function campaignChain(definition, options) {
-    const scenarios = definition.scenarios;
-    if (scenarios.length === 0)
-        throw new Error(`campaign ${definition.id} declares no scenarios`);
-    const known = new Set(scenarios.map((scenario) => scenario.id));
-    if (known.size !== scenarios.length)
-        throw new Error(`campaign ${definition.id} declares a scenario twice`);
-    const start = definition.firstScenario || scenarios[0].id;
-    if (!known.has(start))
-        throw new Error(`campaign ${definition.id} starts on an unknown scenario: ${start}`);
-    return {
-        start,
-        levels: scenarios.map((scenario) => ({
-            id: scenario.id,
-            run: (state, context) => {
-                const result = options.run(scenario, state, context);
-                //the authored chain answers "where next" unless the scenario answered for itself
-                return result.next === undefined ? { ...result, next: scenario.nextScenario ?? null } : result;
-            },
-        })),
-    };
-}
-//# sourceMappingURL=campaign.js.map

package/dist/mwl/campaign.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"campaign.js","sourceRoot":"","sources":["../../src/mwl/campaign.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,aAAa,CAC5B,UAAiC,EACjC,OAA2D;IAE3D,MAAM,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;IACvC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,CAAC,EAAE,wBAAwB,CAAC,CAAC;IAE/F,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;IAChE,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,MAAM;QAAE,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,CAAC,EAAE,4BAA4B,CAAC,CAAC;IAE5G,MAAM,KAAK,GAAG,UAAU,CAAC,aAAa,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1D,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,YAAY,UAAU,CAAC,EAAE,mCAAmC,KAAK,EAAE,CAAC,CAAC;IAE5G,OAAO;QACN,KAAK;QACL,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YACpC,EAAE,EAAE,QAAQ,CAAC,EAAE;YACf,GAAG,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE;gBACvB,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBACrD,iFAAiF;gBACjF,OAAO,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,YAAY,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;YAChG,CAAC;SACD,CAAC,CAAC;KACH,CAAC;AACH,CAAC"}

package/dist/mwl/carryover.d.ts

@@ -1,86 +0,0 @@
-import type { MwlWorld } from './runtime.ts';
-/**
- * Wesnoth's default: the share of a side's gold that survives into the next scenario, unless
- * `[endlevel] carryover_percentage` says otherwise. Its engine carries the winner's gold at 80%,
- * which is the number this mirrors rather than one invented here.
- *
- * @example
- * ```ts
- * import { MWL_DEFAULT_CARRYOVER_PERCENTAGE } from '@datamoc/mw_games/mwl';
- *
- * console.log(MWL_DEFAULT_CARRYOVER_PERCENTAGE); // 80
- * ```
- */
-export declare const MWL_DEFAULT_CARRYOVER_PERCENTAGE = 80;
-/**
- * Which side an ending scenario hands on: the id `[side]` declared, which is the one identity the
- * world uses, keying `world.sides` and `world.gold` and carried by `unit.side` alike (item 277).
- */
-export interface MwlSideRef {
-    /** the id `[side]` declared, the key `world.sides` and `world.gold` use, and `unit.side` holds */
-    readonly id: string;
-}
-/** What `[endlevel]` says when a scenario ends. */
-export interface MwlEndLevel {
-    readonly result: 'victory' | 'defeat';
-    /** `bonus`: gold added on top of the share, not a share of it */
-    readonly bonus?: number;
-    /** `carryover_percentage`: the share of the side's gold kept, 80 when unset */
-    readonly carryoverPercentage?: number;
-    /** `carryover_add`: add the share to the next scenario's gold rather than take the larger of them */
-    readonly carryoverAdd?: boolean;
-    /** `next_scenario`: where the campaign goes instead of the authored chain, null to end it */
-    readonly nextScenario?: string | null;
-}
-/** What one scenario hands to the next. Plain data, so it survives a save. */
-export interface MwlCarryover {
-    readonly result: 'victory' | 'defeat';
-    /** the gold handed on: the side's share, plus the bonus */
-    readonly gold: number;
-    /** whether the share is added to the next scenario's gold or taken as a floor under it */
-    readonly add: boolean;
-    /** ids of the side's units still standing, which become the recall list */
-    readonly recall: readonly string[];
-    /** where the campaign goes next; null ends it */
-    readonly nextScenario: string | null;
-}
-/**
- * Works out what a finished scenario hands on: `bonus` plus `carryover_percentage` of the side's
- * gold, the units of that side still standing, and where the campaign goes next.
- *
- * A side of `null` is a scenario that ended without one (no `[side]`, nothing human-controlled):
- * the result and the next scenario are still recorded, with no gold and nobody to recall.
- *
- * @example
- * ```ts
- * import { endLevelCarryover, carryoverIntoScenario } from '@datamoc/mw_games/mwl';
- *
- * const world = {
- *   variables: {},
- *   gold: { '1': 200 },
- *   sides: { '1': { gold: 0, income: 2, controller: 'human' } },
- *   units: { hero: { hp: 30, x: 1, y: 1, alive: true, side: '1' } },
- *   maps: {},
- *   turn: 1,
- *   status: 'playing' as const,
- * };
- *
- * const carried = endLevelCarryover(world, { id: '1' }, {
- *   result: 'victory',
- *   bonus: 50,
- *   nextScenario: 'siege',
- * });
- *
- * console.log(carried.gold); // 210 - 50 bonus plus 80% of 200
- * console.log(carried.recall); // ['hero'] - still standing, so it comes back
- * console.log(carryoverIntoScenario(carried, 100)); // 210 - the larger of the two, not the sum
- * ```
- */
-export declare function endLevelCarryover(world: MwlWorld, side: MwlSideRef | null, end: MwlEndLevel): MwlCarryover;
-/**
- * What the next scenario starts with, given what it declares and what was carried: the two added
- * when the ending asked for that (`carryover_add`), and otherwise the larger of them, so a share
- * never drags a side below the gold its own scenario gives it.
- */
-export declare function carryoverIntoScenario(carryover: MwlCarryover, declaredGold: number): number;
-//# sourceMappingURL=carryover.d.ts.map

package/dist/mwl/carryover.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"carryover.d.ts","sourceRoot":"","sources":["../../src/mwl/carryover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gCAAgC,KAAK,CAAC;AAEnD;;;GAGG;AACH,MAAM,WAAW,UAAU;IAC1B,kGAAkG;IAClG,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACpB;AAED,mDAAmD;AACnD,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAEtC,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB,+EAA+E;IAC/E,QAAQ,CAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAEtC,qGAAqG;IACrG,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAEhC,6FAA6F;IAC7F,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAED,8EAA8E;AAC9E,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,QAAQ,CAAC;IAEtC,2DAA2D;IAC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,0FAA0F;IAC1F,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IAEtB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAEnC,iDAAiD;IACjD,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,EAAE,GAAG,EAAE,WAAW,GAAG,YAAY,CAgB1G;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAE3F"}

package/dist/mwl/carryover.js

@@ -1,70 +0,0 @@
-/**
- * Wesnoth's default: the share of a side's gold that survives into the next scenario, unless
- * `[endlevel] carryover_percentage` says otherwise. Its engine carries the winner's gold at 80%,
- * which is the number this mirrors rather than one invented here.
- *
- * @example
- * ```ts
- * import { MWL_DEFAULT_CARRYOVER_PERCENTAGE } from '@datamoc/mw_games/mwl';
- *
- * console.log(MWL_DEFAULT_CARRYOVER_PERCENTAGE); // 80
- * ```
- */
-export const MWL_DEFAULT_CARRYOVER_PERCENTAGE = 80;
-/**
- * Works out what a finished scenario hands on: `bonus` plus `carryover_percentage` of the side's
- * gold, the units of that side still standing, and where the campaign goes next.
- *
- * A side of `null` is a scenario that ended without one (no `[side]`, nothing human-controlled):
- * the result and the next scenario are still recorded, with no gold and nobody to recall.
- *
- * @example
- * ```ts
- * import { endLevelCarryover, carryoverIntoScenario } from '@datamoc/mw_games/mwl';
- *
- * const world = {
- *   variables: {},
- *   gold: { '1': 200 },
- *   sides: { '1': { gold: 0, income: 2, controller: 'human' } },
- *   units: { hero: { hp: 30, x: 1, y: 1, alive: true, side: '1' } },
- *   maps: {},
- *   turn: 1,
- *   status: 'playing' as const,
- * };
- *
- * const carried = endLevelCarryover(world, { id: '1' }, {
- *   result: 'victory',
- *   bonus: 50,
- *   nextScenario: 'siege',
- * });
- *
- * console.log(carried.gold); // 210 - 50 bonus plus 80% of 200
- * console.log(carried.recall); // ['hero'] - still standing, so it comes back
- * console.log(carryoverIntoScenario(carried, 100)); // 210 - the larger of the two, not the sum
- * ```
- */
-export function endLevelCarryover(world, side, end) {
-    const percentage = end.carryoverPercentage ?? MWL_DEFAULT_CARRYOVER_PERCENTAGE;
-    const held = side ? (world.gold[side.id] ?? world.sides[side.id]?.gold ?? 0) : 0;
-    return {
-        result: end.result,
-        gold: Math.floor((held * percentage) / 100) + (end.bonus ?? 0),
-        add: end.carryoverAdd ?? false,
-        recall: side
-            ? Object.entries(world.units)
-                .filter(([, unit]) => unit.alive && unit.side === side.id)
-                .map(([id]) => id)
-                .sort()
-            : [],
-        nextScenario: end.nextScenario ?? null,
-    };
-}
-/**
- * What the next scenario starts with, given what it declares and what was carried: the two added
- * when the ending asked for that (`carryover_add`), and otherwise the larger of them, so a share
- * never drags a side below the gold its own scenario gives it.
- */
-export function carryoverIntoScenario(carryover, declaredGold) {
-    return carryover.add ? declaredGold + carryover.gold : Math.max(declaredGold, carryover.gold);
-}
-//# sourceMappingURL=carryover.js.map

package/dist/mwl/carryover.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"carryover.js","sourceRoot":"","sources":["../../src/mwl/carryover.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,gCAAgC,GAAG,EAAE,CAAC;AA6CnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAe,EAAE,IAAuB,EAAE,GAAgB;IAC3F,MAAM,UAAU,GAAG,GAAG,CAAC,mBAAmB,IAAI,gCAAgC,CAAC;IAC/E,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEjF,OAAO;QACN,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,UAAU,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC;QAC9D,GAAG,EAAE,GAAG,CAAC,YAAY,IAAI,KAAK;QAC9B,MAAM,EAAE,IAAI;YACX,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC;iBAC1B,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;iBACzD,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;iBACjB,IAAI,EAAE;YACT,CAAC,CAAC,EAAE;QACL,YAAY,EAAE,GAAG,CAAC,YAAY,IAAI,IAAI;KACtC,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,SAAuB,EAAE,YAAoB;IAClF,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;AAC/F,CAAC"}

package/dist/mwl/catalog.d.ts

@@ -1,98 +0,0 @@
-import type { MwlCompiledGame } from './compiler.ts';
-import type { MwlDiagnostic, MwlNode } from './grammar.ts';
-import { type MwlHookDeclaration } from './hooks.ts';
-/**
- * One declarative cross-table reference: a column of one `[table]` whose every cell must
- * resolve: against a column of another `[table]`, against an authored node-id
- * namespace (`references: { node: 'monster' }` checks every cell names an
- * authored `[monster]` id), or against a closed value set.
- * The declaration names the shape; the *contents* (which column points where, which set is
- * legal) stay game data in the consuming repository.
- *
- * @example
- * ```ts
- * import { compile, validateCatalog } from '@datamoc/mw_games/mwl';
- *
- * const game = compile(
- * 	"[{ tag: 'table', id: 'items', columns: 'id:string', children: [{ tag: 'row', id: 'sword' }] }, { tag: 'table', id: 'recipes', columns: 'ingredient:string', children: [{ tag: 'row', ingredient: 'sword' }] }]",
- * );
- * const declarations = [{ table: 'recipes', column: 'ingredient', references: { table: 'items', column: 'id' } }];
- * console.log(validateCatalog(game, { tableReferences: declarations })); // []
- * ```
- */
-export type MwlTableReference = {
-    /** id of the `[table]` holding the referencing column */
-    readonly table: string;
-    /** column whose cells must resolve */
-    readonly column: string;
-    /** the referenced table and the column its values are drawn from */
-    readonly references: {
-        readonly table: string;
-        readonly column: string;
-    };
-} | {
-    /** id of the `[table]` holding the referencing column */
-    readonly table: string;
-    /** column whose cells must resolve */
-    readonly column: string;
-    /** the exact closed set the column's cells must belong to */
-    readonly oneOf: readonly string[];
-} | {
-    /** id of the `[table]` holding the referencing column */
-    readonly table: string;
-    /** column whose cells must resolve */
-    readonly column: string;
-    /** the authored node-id namespace (a node tag) the column's cells must belong to */
-    readonly references: {
-        readonly node: string;
-    };
-};
-export interface MwlValidationOptions {
-    /** Slots are game-defined. Supplying them enables unknown-slot diagnostics. */
-    readonly slots?: readonly string[];
-    /**
-     * Hooks exported by the game's adapter, by `type:name`. A bare id declares the hook exists;
-     * `MwlHookDeclaration` additionally declares the attributes its `[hook]` calls carry, which
-     * is what turns a typo in one of them into a compile-time diagnostic.
-     */
-    readonly hooks?: readonly (string | MwlHookDeclaration)[];
-    /** Additional game-owned attributes whose values are domain hook references. */
-    readonly hookAttributes?: readonly string[];
-    /** Optional map dimensions used to reject authored coordinates outside the map. */
-    readonly mapBounds?: {
-        readonly width: number;
-        readonly height: number;
-    };
-    /**
-     * Declarative cross-table references (item 362): each entry names a `[table]` column whose
-     * cells must resolve against another table's column, a node-id namespace, or a closed value set. A failure reports
-     * the table, the row, and the offending value. Purely additive and optional: saves, replays
-     * and every existing check are untouched when it is absent.
-     */
-    readonly tableReferences?: readonly MwlTableReference[];
-    /**
-     * What `MWL_DUPLICATE_ID`'s `tag:id` key is scoped to.
-     *
-     * Defaults to `'global'`: the whole compiled catalog, every source file combined, so the
-     * same `[item] id=sword` in two different files is one real duplicate. A game whose own id
-     * convention is meaningful only within one file - a domain- or table-scoped id, reused on
-     * purpose across files the way a database's own per-table primary key is - wants `'file'`
-     * instead, which folds each node's source file into the key so that reuse across files no
-     * longer reports a false `MWL_DUPLICATE_ID`; a real duplicate *within* one file still does.
-     */
-    readonly rowIdScope?: 'global' | 'file';
-}
-/** Semantic checks shared by all games. Domain rules remain in the game adapter. */
-export declare function validateCatalog(game: MwlCompiledGame, options?: MwlValidationOptions): MwlDiagnostic[];
-/**
- * Convenience for adapters that keep parsed nodes rather than compiled games.
- *
- * @example
- * ```ts
- * import { parse, validateCatalogNodes } from '@datamoc/mw_games/mwl';
- *
- * console.log(validateCatalogNodes(parse('[game]\nschema=0.1\n[/game]'))); // []
- * ```
- */
-export declare function validateCatalogNodes(nodes: readonly MwlNode[], options?: MwlValidationOptions): MwlDiagnostic[];
-//# sourceMappingURL=catalog.d.ts.map

package/dist/mwl/catalog.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/mwl/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAmB,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,aAAa,EAAe,OAAO,EAAE,MAAM,cAAc,CAAC;AACxE,OAAO,EAAqE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAIxH;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,iBAAiB,GAC1B;IACA,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oEAAoE;IACpE,QAAQ,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACxE,GACD;IACA,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC,GACD;IACA,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,oFAAoF;IACpF,QAAQ,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9C,CAAC;AAEL,MAAM,WAAW,oBAAoB;IACpC,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,GAAG,kBAAkB,CAAC,EAAE,CAAC;IAC1D,gFAAgF;IAChF,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C,mFAAmF;IACnF,QAAQ,CAAC,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACzE;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAExD;;;;;;;;;OASG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;CACxC;AAED,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,GAAE,oBAAyB,GAAG,aAAa,EAAE,CA4E1G;AA0MD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,OAAO,EAAE,EAAE,OAAO,GAAE,oBAAyB,GAAG,aAAa,EAAE,CAGnH"}