@mark1russell7/strategy-space 0.0.0-stage → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Russell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,52 @@
-# Temporary Holding Version
+# @mark1russell7/strategy-space
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Layout strategies as data. A strategy space gives the stages of an engine, the options of each stage and the ranges of their params. The functions of this package check a space and its configs, and give the id of a config. They also count the space and make grids and seeded samples.
+
+```ts
+import { checkSpace, configId, enumerateSpace, spaceSize, type StrategySpace } from "@mark1russell7/strategy-space";
+
+const space: StrategySpace = {
+  schema: "strategy-space/1",
+  engine: "pack",
+  version: "0.0.1",
+  stages: [
+    { name: "order", options: [{ id: "area", params: [] }, { id: "height", params: [] }] },
+    { name: "placement", options: [{ id: "shelf", params: [{ name: "gap", kind: "int", min: 0, max: 8, default: 2 }] }] },
+  ],
+};
+
+checkSpace(space); // [] : the space is good
+spaceSize(space, { levels: 3 }).base; // 6n : 2 orders, 3 levels of gap
+const configs = enumerateSpace(space, { mode: "sample", n: 4, seed: 7 });
+configId(space, configs[0]!); // the first 16 hex characters of a SHA-256
+```
+
+## What the package has
+
+| Area | Functions |
+| --- | --- |
+| The checks | `checkSpace`, `checkConfig`, `paramProblem` |
+| The id of a config | `canonicalConfig`, `configId` |
+| The count | `spaceSize`, `paramLevels`, `spaceShapeKinds` |
+| The configs | `enumerateSpace` (the modes `grid` and `sample`, the draws `uniform` and `walk`, fixed options) |
+| Two spaces as one | `productSpace`, `joinConfigs`, `splitConfig` |
+| The option schema of a strategy | `listOptions`, `optionDefaults`, `checkOptions`, `clampOptions`, `checkSchema` |
+| The sweeps of the options | `sweepValues`, `sweepOf`, `sweepGrid` |
+| The distinctness gate | `distinctness`, `distinctCount` |
+| The operators of a space | `checkOperators`, `countOperators` |
+| The combinators and the count to a depth | `COMBINATORS`, `checkTerm`, `termDepth`, `canonicalTerm`, `countSpace` |
+
+[`docs/STRATEGY-SPACE.md`](../../docs/STRATEGY-SPACE.md) tells the schema `strategy-space/1` and the rules of each function. [`docs/DISTINCT.md`](../../docs/DISTINCT.md) tells the gate, and [`docs/OPERATORS.md`](../../docs/OPERATORS.md) tells the operators and the combinators.
+
+## Shape kinds
+
+An option can give the shape kinds that it supports, as tags. The option `kinds` gives the list of the known tags. Without `kinds`, each string with text is a kind.
+
+```ts
+checkSpace(space, { kinds: ["rect", "circle"] });
+spaceSize(space, { levels: 3, shapes: ["circle"], kinds: ["rect", "circle"] });
+```
+
+## The same ids as `layout-contract`
+
+The schema, the ids and the samples come from `layout-contract` 0.6.1 with no change. A config has the same `configId`, and a seed gives the same sample. The hash and the random numbers come from `@mark1russell7/rigor-generators`.

package/build/claim.d.ts

@@ -0,0 +1,10 @@
+/** One broken claim, with the ids of the inputs that break it. `layout-contract` uses the same form for the checks of a corpus. */
+export interface ClaimBreak {
+  /** The name of the claim, for example `schema`, `unknown`, `shape` or `members`. */
+  readonly claim: string;
+  /** The text of the break. */
+  readonly detail: string;
+  /** The ids of the inputs that break the claim. The list is empty when the break has no input. */
+  readonly inputs: readonly string[];
+}
+//# sourceMappingURL=claim.d.ts.map

package/build/claim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.d.ts","names":[],"sources":["../src/claim.ts"],"mappings":";iBAGiB;;WAEN;;WAEA;;WAEA"}

package/build/distinct.d.ts

@@ -0,0 +1,49 @@
+/** The hashes of the outputs of one strategy: one hash for each input, by the id of the input. `probeHash` of `layout-contract` gives one hash. */
+export interface OutputHashes {
+  readonly id: string;
+  readonly stage: string;
+  readonly outputs: Readonly<Record<string, string>>;
+}
+/** The options of the gate. */
+export interface DistinctOptions {
+  /** The ids of the inputs of the set. Each variant needs a hash on each of them. */
+  readonly inputs: readonly string[];
+  /** The hash that a strategy gives for an input that it refuses, for example `REFUSED_PROBE` of `layout-contract`. A refused input is not a difference. */
+  readonly refused?: string;
+}
+/**
+ * The verdict of the gate on one variant.
+ * `distinct`: on at least one input, its output differs from the output of each operator of its stage.
+ * `same`: an operator of its stage has the same hash on each input of the set.
+ * `no-read`: the gate cannot decide. An input has no hash, or no input shows a difference from an operator that is not the same.
+ */
+export type DistinctVerdict = "distinct" | "same" | "no-read";
+/** The row of the gate for one variant. */
+export interface DistinctRow {
+  readonly id: string;
+  readonly stage: string;
+  readonly verdict: DistinctVerdict;
+  /** The first id of the variants with the same hash on each input. A variant with a different id is a duplicate of it. */
+  readonly canonical: string;
+  /** The operators with the same hash on each input. */
+  readonly sameAs: readonly string[];
+  /** The operators with no difference on a compared input, and no equal hash on each input. */
+  readonly undecided: readonly string[];
+  /** The inputs of the set with no hash for this variant. */
+  readonly missing: readonly string[];
+  /** The first input where the outputs differ from each operator, by the id of the operator. */
+  readonly differsOn: Readonly<Record<string, string>>;
+}
+/**
+ * This function gives the verdict of the gate on each variant, sorted by id.
+ * It compares a variant only with the operators of its stage. A stage with no operator gives `distinct` to each complete variant.
+ *
+ * @param operators - The hashes of the existing operators.
+ * @param variants - The hashes of the variants that the gate examines.
+ * @param options - The inputs of the set and the refused hash.
+ * @throws Error when an id is in the operators or in the variants more than once, or when the set has no input.
+ */
+export declare function distinctness(operators: readonly OutputHashes[], variants: readonly OutputHashes[], options: DistinctOptions): DistinctRow[];
+/** This function gives the count of the distinct variants: the canonical variants with the verdict `distinct`. A duplicate does not count. */
+export declare function distinctCount(rows: readonly DistinctRow[]): number;
+//# sourceMappingURL=distinct.d.ts.map

package/build/distinct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distinct.d.ts","names":[],"sources":["../src/distinct.ts"],"mappings":";iBAIiB;WACN;WACA;WACA,SAAS,SAAS;;;iBAIZ;;WAEN;;WAEA;;;;;;;;YASC;;iBAGK;WACN;WACA;WACA,SAAS;;WAET;;WAEA;;WAEA;;WAEA;;WAEA,WAAW,SAAS;;;;;;;;;;;wBAuBf,aAAa,oBAAoB,gBAAgB,mBAAmB,gBAAgB,SAAS,kBAAkB;;wBAiC/G,cAAc,eAAe"}

package/build/distinct.js

@@ -0,0 +1,61 @@
+// src/distinct.ts
+/** This function gives the key of the hashes of a strategy on the inputs, in the order of the inputs. */
+function vectorKey(s, inputs) {
+	return JSON.stringify(inputs.map((b) => s.outputs[b] ?? null));
+}
+/** This function gives the ids that are in the list more than once. */
+function repeated(ids) {
+	const seen = /* @__PURE__ */ new Set();
+	return [...new Set(ids.filter((id) => seen.has(id) || !seen.add(id)))];
+}
+/**
+* This function gives the verdict of the gate on each variant, sorted by id.
+* It compares a variant only with the operators of its stage. A stage with no operator gives `distinct` to each complete variant.
+*
+* @param operators - The hashes of the existing operators.
+* @param variants - The hashes of the variants that the gate examines.
+* @param options - The inputs of the set and the refused hash.
+* @throws Error when an id is in the operators or in the variants more than once, or when the set has no input.
+*/
+function distinctness(operators, variants, options) {
+	const { inputs, refused } = options;
+	if (inputs.length === 0) throw new Error("The gate has no input.");
+	const twice = repeated([...operators.map((o) => o.id), ...variants.map((v) => v.id)]);
+	if (twice.length > 0) throw new Error(`These ids are not unique: ${twice.join(", ")}.`);
+	const canonical = /* @__PURE__ */ new Map();
+	for (const v of [...variants].sort((a, b) => a.id < b.id ? -1 : 1)) {
+		const key = `${v.stage}\u0000${vectorKey(v, inputs)}`;
+		if (!canonical.has(key)) canonical.set(key, v.id);
+	}
+	const compared = (a, b) => a !== void 0 && b !== void 0 && a !== refused && b !== refused;
+	return [...variants].sort((a, b) => a.id < b.id ? -1 : 1).map((v) => {
+		const missing = inputs.filter((b) => v.outputs[b] === void 0);
+		const sameAs = [];
+		const undecided = [];
+		const differsOn = {};
+		for (const op of operators.filter((o) => o.stage === v.stage).sort((a, b) => a.id < b.id ? -1 : 1)) {
+			const input = inputs.find((b) => compared(v.outputs[b], op.outputs[b]) && v.outputs[b] !== op.outputs[b]);
+			if (input !== void 0) differsOn[op.id] = input;
+			else if (missing.length === 0 && inputs.every((b) => op.outputs[b] === v.outputs[b])) sameAs.push(op.id);
+			else undecided.push(op.id);
+		}
+		const verdict = missing.length > 0 ? "no-read" : sameAs.length > 0 ? "same" : undecided.length > 0 ? "no-read" : "distinct";
+		return {
+			id: v.id,
+			stage: v.stage,
+			verdict,
+			canonical: canonical.get(`${v.stage}\u0000${vectorKey(v, inputs)}`),
+			sameAs,
+			undecided,
+			missing,
+			differsOn
+		};
+	});
+}
+/** This function gives the count of the distinct variants: the canonical variants with the verdict `distinct`. A duplicate does not count. */
+function distinctCount(rows) {
+	return rows.filter((r) => r.verdict === "distinct" && r.canonical === r.id).length;
+}
+export { distinctCount, distinctness };
+
+//# sourceMappingURL=distinct.js.map

package/build/distinct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"distinct.js","names":[],"sources":["../src/distinct.ts"],"sourcesContent":["// The distinctness gate (`docs/DISTINCT.md`). A variant counts only when its output differs from each operator of its stage on at least one input.\n// The caller gives the hash of the output of each strategy on each input of a fixed set. The gate came from `highways` 27b40c8.\n\n/** The hashes of the outputs of one strategy: one hash for each input, by the id of the input. `probeHash` of `layout-contract` gives one hash. */\nexport interface OutputHashes {\n  readonly id: string;\n  readonly stage: string;\n  readonly outputs: Readonly<Record<string, string>>;\n}\n\n/** The options of the gate. */\nexport interface DistinctOptions {\n  /** The ids of the inputs of the set. Each variant needs a hash on each of them. */\n  readonly inputs: readonly string[];\n  /** The hash that a strategy gives for an input that it refuses, for example `REFUSED_PROBE` of `layout-contract`. A refused input is not a difference. */\n  readonly refused?: string;\n}\n\n/**\n * The verdict of the gate on one variant.\n * `distinct`: on at least one input, its output differs from the output of each operator of its stage.\n * `same`: an operator of its stage has the same hash on each input of the set.\n * `no-read`: the gate cannot decide. An input has no hash, or no input shows a difference from an operator that is not the same.\n */\nexport type DistinctVerdict = \"distinct\" | \"same\" | \"no-read\";\n\n/** The row of the gate for one variant. */\nexport interface DistinctRow {\n  readonly id: string;\n  readonly stage: string;\n  readonly verdict: DistinctVerdict;\n  /** The first id of the variants with the same hash on each input. A variant with a different id is a duplicate of it. */\n  readonly canonical: string;\n  /** The operators with the same hash on each input. */\n  readonly sameAs: readonly string[];\n  /** The operators with no difference on a compared input, and no equal hash on each input. */\n  readonly undecided: readonly string[];\n  /** The inputs of the set with no hash for this variant. */\n  readonly missing: readonly string[];\n  /** The first input where the outputs differ from each operator, by the id of the operator. */\n  readonly differsOn: Readonly<Record<string, string>>;\n}\n\n/** This function gives the key of the hashes of a strategy on the inputs, in the order of the inputs. */\nfunction vectorKey(s: OutputHashes, inputs: readonly string[]): string {\n  return JSON.stringify(inputs.map((b) => s.outputs[b] ?? null));\n}\n\n/** This function gives the ids that are in the list more than once. */\nfunction repeated(ids: readonly string[]): string[] {\n  const seen = new Set<string>();\n  return [...new Set(ids.filter((id) => seen.has(id) || !seen.add(id)))];\n}\n\n/**\n * This function gives the verdict of the gate on each variant, sorted by id.\n * It compares a variant only with the operators of its stage. A stage with no operator gives `distinct` to each complete variant.\n *\n * @param operators - The hashes of the existing operators.\n * @param variants - The hashes of the variants that the gate examines.\n * @param options - The inputs of the set and the refused hash.\n * @throws Error when an id is in the operators or in the variants more than once, or when the set has no input.\n */\nexport function distinctness(operators: readonly OutputHashes[], variants: readonly OutputHashes[], options: DistinctOptions): DistinctRow[] {\n  const { inputs, refused } = options;\n  if (inputs.length === 0) throw new Error(\"The gate has no input.\");\n  const twice = repeated([...operators.map((o) => o.id), ...variants.map((v) => v.id)]);\n  if (twice.length > 0) throw new Error(`These ids are not unique: ${twice.join(\", \")}.`);\n\n  // The first id of each class of variants with the same hashes.\n  const canonical = new Map<string, string>();\n  for (const v of [...variants].sort((a, b) => (a.id < b.id ? -1 : 1))) {\n    const key = `${v.stage}\\u0000${vectorKey(v, inputs)}`;\n    if (!canonical.has(key)) canonical.set(key, v.id);\n  }\n\n  const compared = (a: string | undefined, b: string | undefined): boolean => a !== undefined && b !== undefined && a !== refused && b !== refused;\n  return [...variants]\n    .sort((a, b) => (a.id < b.id ? -1 : 1))\n    .map((v) => {\n      const missing = inputs.filter((b) => v.outputs[b] === undefined);\n      const sameAs: string[] = [];\n      const undecided: string[] = [];\n      const differsOn: Record<string, string> = {};\n      for (const op of operators.filter((o) => o.stage === v.stage).sort((a, b) => (a.id < b.id ? -1 : 1))) {\n        const input = inputs.find((b) => compared(v.outputs[b], op.outputs[b]) && v.outputs[b] !== op.outputs[b]);\n        if (input !== undefined) differsOn[op.id] = input;\n        else if (missing.length === 0 && inputs.every((b) => op.outputs[b] === v.outputs[b])) sameAs.push(op.id);\n        else undecided.push(op.id);\n      }\n      const verdict: DistinctVerdict = missing.length > 0 ? \"no-read\" : sameAs.length > 0 ? \"same\" : undecided.length > 0 ? \"no-read\" : \"distinct\";\n      return { id: v.id, stage: v.stage, verdict, canonical: canonical.get(`${v.stage}\\u0000${vectorKey(v, inputs)}`)!, sameAs, undecided, missing, differsOn };\n    });\n}\n\n/** This function gives the count of the distinct variants: the canonical variants with the verdict `distinct`. A duplicate does not count. */\nexport function distinctCount(rows: readonly DistinctRow[]): number {\n  return rows.filter((r) => r.verdict === \"distinct\" && r.canonical === r.id).length;\n}\n"],"mappings":";;AA4CA,SAAS,UAAU,GAAiB,QAAmC;CACrE,OAAO,KAAK,UAAU,OAAO,KAAK,MAAM,EAAE,QAAQ,MAAM,IAAI,CAAC;AAC/D;;AAGA,SAAS,SAAS,KAAkC;CAClD,MAAM,uBAAO,IAAI,IAAY;CAC7B,OAAO,CAAC,GAAG,IAAI,IAAI,IAAI,QAAQ,OAAO,KAAK,IAAI,EAAE,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,CAAC;AACvE;;;;;;;;;;AAWA,SAAgB,aAAa,WAAoC,UAAmC,SAAyC;CAC3I,MAAM,EAAE,QAAQ,YAAY;CAC5B,IAAI,OAAO,WAAW,GAAG,MAAM,IAAI,MAAM,wBAAwB;CACjE,MAAM,QAAQ,SAAS,CAAC,GAAG,UAAU,KAAK,MAAM,EAAE,EAAE,GAAG,GAAG,SAAS,KAAK,MAAM,EAAE,EAAE,CAAC,CAAC;CACpF,IAAI,MAAM,SAAS,GAAG,MAAM,IAAI,MAAM,6BAA6B,MAAM,KAAK,IAAI,EAAE,EAAE;CAGtF,MAAM,4BAAY,IAAI,IAAoB;CAC1C,KAAK,MAAM,KAAK,CAAC,GAAG,QAAQ,CAAC,CAAC,MAAM,GAAG,MAAO,EAAE,KAAK,EAAE,KAAK,KAAK,CAAE,GAAG;EACpE,MAAM,MAAM,GAAG,EAAE,MAAM,QAAQ,UAAU,GAAG,MAAM;EAClD,IAAI,CAAC,UAAU,IAAI,GAAG,GAAG,UAAU,IAAI,KAAK,EAAE,EAAE;CAClD;CAEA,MAAM,YAAY,GAAuB,MAAmC,MAAM,KAAA,KAAa,MAAM,KAAA,KAAa,MAAM,WAAW,MAAM;CACzI,OAAO,CAAC,GAAG,QAAQ,CAAC,CACjB,MAAM,GAAG,MAAO,EAAE,KAAK,EAAE,KAAK,KAAK,CAAE,CAAC,CACtC,KAAK,MAAM;EACV,MAAM,UAAU,OAAO,QAAQ,MAAM,EAAE,QAAQ,OAAO,KAAA,CAAS;EAC/D,MAAM,SAAmB,CAAC;EAC1B,MAAM,YAAsB,CAAC;EAC7B,MAAM,YAAoC,CAAC;EAC3C,KAAK,MAAM,MAAM,UAAU,QAAQ,MAAM,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC,MAAM,GAAG,MAAO,EAAE,KAAK,EAAE,KAAK,KAAK,CAAE,GAAG;GACpG,MAAM,QAAQ,OAAO,MAAM,MAAM,SAAS,EAAE,QAAQ,IAAI,GAAG,QAAQ,EAAE,KAAK,EAAE,QAAQ,OAAO,GAAG,QAAQ,EAAE;GACxG,IAAI,UAAU,KAAA,GAAW,UAAU,GAAG,MAAM;QACvC,IAAI,QAAQ,WAAW,KAAK,OAAO,OAAO,MAAM,GAAG,QAAQ,OAAO,EAAE,QAAQ,EAAE,GAAG,OAAO,KAAK,GAAG,EAAE;QAClG,UAAU,KAAK,GAAG,EAAE;EAC3B;EACA,MAAM,UAA2B,QAAQ,SAAS,IAAI,YAAY,OAAO,SAAS,IAAI,SAAS,UAAU,SAAS,IAAI,YAAY;EAClI,OAAO;GAAE,IAAI,EAAE;GAAI,OAAO,EAAE;GAAO;GAAS,WAAW,UAAU,IAAI,GAAG,EAAE,MAAM,QAAQ,UAAU,GAAG,MAAM,GAAG;GAAI;GAAQ;GAAW;GAAS;EAAU;CAC1J,CAAC;AACL;;AAGA,SAAgB,cAAc,MAAsC;CAClE,OAAO,KAAK,QAAQ,MAAM,EAAE,YAAY,cAAc,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC;AAC9E"}

package/build/index.d.ts

@@ -0,0 +1,7 @@
+import { ClaimBreak } from "./claim.js";
+import { DistinctOptions, DistinctRow, DistinctVerdict, OutputHashes, distinctCount, distinctness } from "./distinct.js";
+import { OPERATOR_SCHEMA, OPERATOR_SOURCES, Operator, OperatorCount, OperatorSet, OperatorSource, checkOperators, countOperators, needsOperator } from "./operators.js";
+import { AnyOption, BooleanOption, DeclaredStrategy, EnumOption, ListItem, NoDefault, NoDefaultReason, NumberOption, OptionDeclaration, OptionIssue, OptionScale, OptionSchema, OptionSetting, SweepOptions, ValueOption, checkOptions, checkSchema, clampOptions, declarationIssues, listOptions, optionDefaults, optionIssue, sweepGrid, sweepOf, sweepValues } from "./strategy-options.js";
+import { EnumerateOptions, GridOptions, KindOptions, MemberRule, OptionRef, OptionSupports, ParamKind, ParamValue, ParamWhen, STRATEGY_SPACE_SCHEMA, SampleOptions, ShapeFilter, SpaceConstraint, SpaceParam, SpaceSize, SpaceSizeOptions, SpaceStage, StageChoice, StageOption, StrategyConfig, StrategySpace, canonicalConfig, checkConfig, checkSpace, configId, enumerateSpace, joinConfigs, paramActive, paramLevels, paramProblem, paramValue, productSpace, spaceShapeKinds, spaceSize, splitConfig } from "./strategy-space.js";
+import { BUDGET_KEYS, COMBINATORS, Combinator, CountOptions, StrategyTerm, TermCount, canonicalTerm, checkCombinators, checkTerm, countSpace, dispatchIndex, termDepth } from "./terms.js";
+export { AnyOption, BUDGET_KEYS, BooleanOption, COMBINATORS, type ClaimBreak, Combinator, CountOptions, DeclaredStrategy, DistinctOptions, DistinctRow, DistinctVerdict, EnumOption, EnumerateOptions, GridOptions, KindOptions, ListItem, MemberRule, NoDefault, NoDefaultReason, NumberOption, OPERATOR_SCHEMA, OPERATOR_SOURCES, Operator, OperatorCount, OperatorSet, OperatorSource, OptionDeclaration, OptionIssue, OptionRef, OptionScale, OptionSchema, OptionSetting, OptionSupports, OutputHashes, ParamKind, ParamValue, ParamWhen, STRATEGY_SPACE_SCHEMA, SampleOptions, ShapeFilter, SpaceConstraint, SpaceParam, SpaceSize, SpaceSizeOptions, SpaceStage, StageChoice, StageOption, StrategyConfig, StrategySpace, StrategyTerm, SweepOptions, TermCount, ValueOption, canonicalConfig, canonicalTerm, checkCombinators, checkConfig, checkOperators, checkOptions, checkSchema, checkSpace, checkTerm, clampOptions, configId, countOperators, countSpace, declarationIssues, dispatchIndex, distinctCount, distinctness, enumerateSpace, joinConfigs, listOptions, needsOperator, optionDefaults, optionIssue, paramActive, paramLevels, paramProblem, paramValue, productSpace, spaceShapeKinds, spaceSize, splitConfig, sweepGrid, sweepOf, sweepValues, termDepth };

package/build/index.js

@@ -0,0 +1,6 @@
+import { distinctCount, distinctness } from "./distinct.js";
+import { OPERATOR_SCHEMA, OPERATOR_SOURCES, checkOperators, countOperators, needsOperator } from "./operators.js";
+import { checkOptions, checkSchema, clampOptions, declarationIssues, listOptions, optionDefaults, optionIssue, sweepGrid, sweepOf, sweepValues } from "./strategy-options.js";
+import { STRATEGY_SPACE_SCHEMA, canonicalConfig, checkConfig, checkSpace, configId, enumerateSpace, joinConfigs, paramActive, paramLevels, paramProblem, paramValue, productSpace, spaceShapeKinds, spaceSize, splitConfig } from "./strategy-space.js";
+import { BUDGET_KEYS, COMBINATORS, canonicalTerm, checkCombinators, checkTerm, countSpace, dispatchIndex, termDepth } from "./terms.js";
+export { BUDGET_KEYS, COMBINATORS, OPERATOR_SCHEMA, OPERATOR_SOURCES, STRATEGY_SPACE_SCHEMA, canonicalConfig, canonicalTerm, checkCombinators, checkConfig, checkOperators, checkOptions, checkSchema, checkSpace, checkTerm, clampOptions, configId, countOperators, countSpace, declarationIssues, dispatchIndex, distinctCount, distinctness, enumerateSpace, joinConfigs, listOptions, needsOperator, optionDefaults, optionIssue, paramActive, paramLevels, paramProblem, paramValue, productSpace, spaceShapeKinds, spaceSize, splitConfig, sweepGrid, sweepOf, sweepValues, termDepth };

package/build/operators.d.ts

@@ -0,0 +1,55 @@
+import { ClaimBreak } from "./claim.js";
+import { StageOption, StrategySpace } from "./strategy-space.js";
+/** The schema of a set of operators. */
+export declare const OPERATOR_SCHEMA = "strategy-operators/1";
+/** The sources of an operator: a method from a paper or a book, a method of this project, or a change of a parent operator. */
+export declare const OPERATOR_SOURCES: readonly ["literature", "ours", "mutation"];
+/** The source of an operator. */
+export type OperatorSource = (typeof OPERATOR_SOURCES)[number];
+/** The declaration of one operator: one mechanism at one stage of a space. A param value of an option is not an operator. */
+export interface Operator {
+  /** The id of the option of the stage that this operator is. */
+  readonly id: string;
+  /** The name of the stage of the operator. */
+  readonly stage: string;
+  readonly source: OperatorSource;
+  /** The id of the operator of the same stage that this operator changes. A `mutation` has a parent. The other sources can have one. */
+  readonly parent?: string;
+  /** The reference of a `literature` operator, for example the authors, the year and the title. */
+  readonly cite?: string;
+  /** The path of the test file or the test folder of the operator, from the root of its repository, or a list of these paths. */
+  readonly test: string | readonly string[];
+  /** The text that tells the mechanism of the operator. */
+  readonly summary: string;
+}
+/** The operators of one space. */
+export interface OperatorSet {
+  readonly schema: typeof OPERATOR_SCHEMA;
+  /** The `engine` of the space. */
+  readonly engine: string;
+  readonly operators: readonly Operator[];
+}
+/** The count of the operators of a set, by stage and by source. */
+export interface OperatorCount {
+  readonly total: number;
+  readonly byStage: Readonly<Record<string, number>>;
+  readonly bySource: Readonly<Record<OperatorSource, number>>;
+}
+/**
+ * This function gives the breaks of a set of operators against its space. An empty list tells that the set is good.
+ * The claims are `schema`, `engine`, `unknown`, `duplicate`, `source`, `parent`, `cycle`, `cite`, `test`, `summary`, `undeclared` and `not-operator`.
+ * An option that `needsOperator` accepts and that has no operator gives the claim `undeclared`. An operator of another option gives `not-operator`.
+ * The `inputs` of each break have the stage and the id.
+ */
+/**
+ * This function tells if an option is its own mechanism, so it needs an operator. An identity option needs none.
+ * A meta option with `chooses: true` needs none. A meta option that changes the output of its members needs one.
+ */
+export declare function needsOperator(option: StageOption): boolean;
+export declare function checkOperators(space: StrategySpace, set: OperatorSet): ClaimBreak[];
+/**
+ * This function gives the count of the operators of a set, by stage and by source. It counts each operator of the set.
+ * `checkOperators` refuses an operator of an option that `needsOperator` refuses. So a good set counts only the mechanisms.
+ */
+export declare function countOperators(set: OperatorSet): OperatorCount;
+//# sourceMappingURL=operators.d.ts.map

package/build/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","names":[],"sources":["../src/operators.ts"],"mappings":";;;qBAKa;;qBAGA;;YAGD,yBAAyB;;iBAGpB;;WAEN;;WAEA;WACA,QAAQ;;WAER;;WAEA;;WAEA;;WAEA;;;iBAIM;WACN,eAAe;;WAEf;WACA,oBAAoB;;;iBAId;WACN;WACA,SAAS,SAAS;WAClB,UAAU,SAAS,OAAO;;;;;;;;;;;;wBAerB,cAAc,QAAQ;wBAKtB,eAAe,OAAO,eAAe,KAAK,cAAc;;;;;wBAmDxD,eAAe,KAAK,cAAc"}

package/build/operators.js

@@ -0,0 +1,95 @@
+// src/operators.ts
+/** The schema of a set of operators. */
+const OPERATOR_SCHEMA = "strategy-operators/1";
+/** The sources of an operator: a method from a paper or a book, a method of this project, or a change of a parent operator. */
+const OPERATOR_SOURCES = [
+	"literature",
+	"ours",
+	"mutation"
+];
+const isText = (value) => typeof value === "string" && value.trim() !== "";
+/**
+* This function gives the breaks of a set of operators against its space. An empty list tells that the set is good.
+* The claims are `schema`, `engine`, `unknown`, `duplicate`, `source`, `parent`, `cycle`, `cite`, `test`, `summary`, `undeclared` and `not-operator`.
+* An option that `needsOperator` accepts and that has no operator gives the claim `undeclared`. An operator of another option gives `not-operator`.
+* The `inputs` of each break have the stage and the id.
+*/
+/**
+* This function tells if an option is its own mechanism, so it needs an operator. An identity option needs none.
+* A meta option with `chooses: true` needs none. A meta option that changes the output of its members needs one.
+*/
+function needsOperator(option) {
+	if (option.identity === true) return false;
+	return option.members?.chooses !== true;
+}
+function checkOperators(space, set) {
+	const out = [];
+	const add = (claim, detail, inputs = []) => {
+		out.push({
+			claim,
+			detail,
+			inputs
+		});
+	};
+	if (set.schema !== "strategy-operators/1") add("schema", `the schema is ${JSON.stringify(set.schema)}, not ${OPERATOR_SCHEMA}`);
+	if (set.engine !== space.engine) add("engine", `the set is for the engine ${JSON.stringify(set.engine)}, not ${space.engine}`);
+	const seen = /* @__PURE__ */ new Map();
+	for (const o of set.operators) {
+		const key = `${o.stage}.${o.id}`;
+		const stage = space.stages.find((s) => s.name === o.stage);
+		const option = stage?.options.find((x) => x.id === o.id);
+		if (stage === void 0) add("unknown", `the operator ${key} names the unknown stage ${o.stage}`, [key]);
+		else if (option === void 0) add("unknown", `the operator ${key} is not an option of the stage ${o.stage}`, [key]);
+		else if (!needsOperator(option)) add("not-operator", `the option ${key} is an identity option or only chooses a member, so it is not an operator`, [key]);
+		if (seen.has(key)) add("duplicate", `the set has the operator ${key} two times`, [key]);
+		else seen.set(key, o);
+		if (!OPERATOR_SOURCES.includes(o.source)) add("source", `the operator ${key} has the source ${JSON.stringify(o.source)}, not one of ${OPERATOR_SOURCES.join(", ")}`, [key]);
+		if (o.source === "mutation" && o.parent === void 0) add("parent", `the mutation ${key} has no parent`, [key]);
+		if (o.source === "literature" && !isText(o.cite)) add("cite", `the literature operator ${key} has no cite`, [key]);
+		const tests = Array.isArray(o.test) ? o.test : [o.test];
+		if (tests.length === 0 || !tests.every(isText)) add("test", `the operator ${key} has no test file or test folder`, [key]);
+		if (!isText(o.summary)) add("summary", `the operator ${key} has no summary`, [key]);
+	}
+	for (const o of seen.values()) {
+		if (o.parent === void 0) continue;
+		const key = `${o.stage}.${o.id}`;
+		if (!seen.has(`${o.stage}.${o.parent}`)) {
+			add("parent", `the parent ${o.parent} of the operator ${key} is not an operator of the stage ${o.stage}`, [key]);
+			continue;
+		}
+		const path = /* @__PURE__ */ new Set([o.id]);
+		for (let p = seen.get(`${o.stage}.${o.parent}`); p?.parent !== void 0; p = seen.get(`${o.stage}.${p.parent}`)) {
+			if (path.has(p.id)) {
+				add("cycle", `the parents of the operator ${key} make a cycle`, [key]);
+				break;
+			}
+			path.add(p.id);
+		}
+	}
+	for (const s of space.stages) for (const option of s.options) if (needsOperator(option) && !seen.has(`${s.name}.${option.id}`)) add("undeclared", `the option ${s.name}.${option.id} has no operator`, [`${s.name}.${option.id}`]);
+	return out;
+}
+/**
+* This function gives the count of the operators of a set, by stage and by source. It counts each operator of the set.
+* `checkOperators` refuses an operator of an option that `needsOperator` refuses. So a good set counts only the mechanisms.
+*/
+function countOperators(set) {
+	const byStage = {};
+	const bySource = {
+		literature: 0,
+		ours: 0,
+		mutation: 0
+	};
+	for (const o of set.operators) {
+		byStage[o.stage] = (byStage[o.stage] ?? 0) + 1;
+		bySource[o.source] += 1;
+	}
+	return {
+		total: set.operators.length,
+		byStage,
+		bySource
+	};
+}
+export { OPERATOR_SCHEMA, OPERATOR_SOURCES, checkOperators, countOperators, needsOperator };
+
+//# sourceMappingURL=operators.js.map

package/build/operators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","names":[],"sources":["../src/operators.ts"],"sourcesContent":["// The operators of a strategy space (`docs/OPERATORS.md`): the declaration of each mechanism at one stage, with its source and its parent.\nimport type { ClaimBreak } from \"./claim.ts\";\nimport type { StageOption, StrategySpace } from \"./strategy-space.ts\";\n\n/** The schema of a set of operators. */\nexport const OPERATOR_SCHEMA = \"strategy-operators/1\";\n\n/** The sources of an operator: a method from a paper or a book, a method of this project, or a change of a parent operator. */\nexport const OPERATOR_SOURCES = [\"literature\", \"ours\", \"mutation\"] as const;\n\n/** The source of an operator. */\nexport type OperatorSource = (typeof OPERATOR_SOURCES)[number];\n\n/** The declaration of one operator: one mechanism at one stage of a space. A param value of an option is not an operator. */\nexport interface Operator {\n  /** The id of the option of the stage that this operator is. */\n  readonly id: string;\n  /** The name of the stage of the operator. */\n  readonly stage: string;\n  readonly source: OperatorSource;\n  /** The id of the operator of the same stage that this operator changes. A `mutation` has a parent. The other sources can have one. */\n  readonly parent?: string;\n  /** The reference of a `literature` operator, for example the authors, the year and the title. */\n  readonly cite?: string;\n  /** The path of the test file or the test folder of the operator, from the root of its repository, or a list of these paths. */\n  readonly test: string | readonly string[];\n  /** The text that tells the mechanism of the operator. */\n  readonly summary: string;\n}\n\n/** The operators of one space. */\nexport interface OperatorSet {\n  readonly schema: typeof OPERATOR_SCHEMA;\n  /** The `engine` of the space. */\n  readonly engine: string;\n  readonly operators: readonly Operator[];\n}\n\n/** The count of the operators of a set, by stage and by source. */\nexport interface OperatorCount {\n  readonly total: number;\n  readonly byStage: Readonly<Record<string, number>>;\n  readonly bySource: Readonly<Record<OperatorSource, number>>;\n}\n\nconst isText = (value: unknown): value is string => typeof value === \"string\" && value.trim() !== \"\";\n\n/**\n * This function gives the breaks of a set of operators against its space. An empty list tells that the set is good.\n * The claims are `schema`, `engine`, `unknown`, `duplicate`, `source`, `parent`, `cycle`, `cite`, `test`, `summary`, `undeclared` and `not-operator`.\n * An option that `needsOperator` accepts and that has no operator gives the claim `undeclared`. An operator of another option gives `not-operator`.\n * The `inputs` of each break have the stage and the id.\n */\n/**\n * This function tells if an option is its own mechanism, so it needs an operator. An identity option needs none.\n * A meta option with `chooses: true` needs none. A meta option that changes the output of its members needs one.\n */\nexport function needsOperator(option: StageOption): boolean {\n  if (option.identity === true) return false;\n  return option.members?.chooses !== true;\n}\n\nexport function checkOperators(space: StrategySpace, set: OperatorSet): ClaimBreak[] {\n  const out: ClaimBreak[] = [];\n  const add = (claim: string, detail: string, inputs: readonly string[] = []): void => {\n    out.push({ claim, detail, inputs });\n  };\n  if (set.schema !== OPERATOR_SCHEMA) add(\"schema\", `the schema is ${JSON.stringify(set.schema)}, not ${OPERATOR_SCHEMA}`);\n  if (set.engine !== space.engine) add(\"engine\", `the set is for the engine ${JSON.stringify(set.engine)}, not ${space.engine}`);\n  const seen = new Map<string, Operator>();\n  for (const o of set.operators) {\n    const key = `${o.stage}.${o.id}`;\n    const stage = space.stages.find((s) => s.name === o.stage);\n    const option = stage?.options.find((x) => x.id === o.id);\n    if (stage === undefined) add(\"unknown\", `the operator ${key} names the unknown stage ${o.stage}`, [key]);\n    else if (option === undefined) add(\"unknown\", `the operator ${key} is not an option of the stage ${o.stage}`, [key]);\n    else if (!needsOperator(option)) add(\"not-operator\", `the option ${key} is an identity option or only chooses a member, so it is not an operator`, [key]);\n    if (seen.has(key)) add(\"duplicate\", `the set has the operator ${key} two times`, [key]);\n    else seen.set(key, o);\n    if (!(OPERATOR_SOURCES as readonly string[]).includes(o.source)) add(\"source\", `the operator ${key} has the source ${JSON.stringify(o.source)}, not one of ${OPERATOR_SOURCES.join(\", \")}`, [key]);\n    if (o.source === \"mutation\" && o.parent === undefined) add(\"parent\", `the mutation ${key} has no parent`, [key]);\n    if (o.source === \"literature\" && !isText(o.cite)) add(\"cite\", `the literature operator ${key} has no cite`, [key]);\n    const tests: readonly unknown[] = Array.isArray(o.test) ? o.test : [o.test];\n    if (tests.length === 0 || !tests.every(isText)) add(\"test\", `the operator ${key} has no test file or test folder`, [key]);\n    if (!isText(o.summary)) add(\"summary\", `the operator ${key} has no summary`, [key]);\n  }\n  for (const o of seen.values()) {\n    if (o.parent === undefined) continue;\n    const key = `${o.stage}.${o.id}`;\n    if (!seen.has(`${o.stage}.${o.parent}`)) {\n      add(\"parent\", `the parent ${o.parent} of the operator ${key} is not an operator of the stage ${o.stage}`, [key]);\n      continue;\n    }\n    // A walk up the parents finds a cycle when it comes back to an operator that it saw.\n    const path = new Set<string>([o.id]);\n    for (let p = seen.get(`${o.stage}.${o.parent}`); p?.parent !== undefined; p = seen.get(`${o.stage}.${p.parent}`)) {\n      if (path.has(p.id)) {\n        add(\"cycle\", `the parents of the operator ${key} make a cycle`, [key]);\n        break;\n      }\n      path.add(p.id);\n    }\n  }\n  for (const s of space.stages)\n    for (const option of s.options)\n      if (needsOperator(option) && !seen.has(`${s.name}.${option.id}`)) add(\"undeclared\", `the option ${s.name}.${option.id} has no operator`, [`${s.name}.${option.id}`]);\n  return out;\n}\n\n/**\n * This function gives the count of the operators of a set, by stage and by source. It counts each operator of the set.\n * `checkOperators` refuses an operator of an option that `needsOperator` refuses. So a good set counts only the mechanisms.\n */\nexport function countOperators(set: OperatorSet): OperatorCount {\n  const byStage: Record<string, number> = {};\n  const bySource: Record<OperatorSource, number> = { literature: 0, ours: 0, mutation: 0 };\n  for (const o of set.operators) {\n    byStage[o.stage] = (byStage[o.stage] ?? 0) + 1;\n    bySource[o.source] += 1;\n  }\n  return { total: set.operators.length, byStage, bySource };\n}\n"],"mappings":"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"}

package/build/space-walk.js

@@ -0,0 +1,48 @@
+// src/space-walk.ts
+const refMatches = (ref, choices) => (choices.get(ref.stage) ?? null) === ref.option;
+/** This function tells if the option choices keep a constraint. */
+function holds(c, choices) {
+	if (!refMatches(c.if, choices)) return true;
+	return "not" in c.then ? !refMatches(c.then.not, choices) : refMatches(c.then, choices);
+}
+const otherStage = (c) => "not" in c.then ? c.then.not.stage : c.then.stage;
+/** This function tells if an option of a stage keeps each constraint between that stage and the stages that a walk has fixed. */
+function fitsWalk(constraints, fixed, stage, id) {
+	fixed.set(stage, id);
+	const ok = constraints.every((c) => !fixed.has(c.if.stage === stage ? otherStage(c) : c.if.stage) || holds(c, fixed));
+	fixed.delete(stage);
+	return ok;
+}
+/**
+* This function gives the plan of a walk. Stages of equal size keep the order of the space.
+* The stages of `first` go first, for example the stages of the sample option `fixed`. Thus the other stages draw only from the options that keep the constraints with them.
+*/
+function walkPlan(stages, lists, constraints, n, first = /* @__PURE__ */ new Set()) {
+	return {
+		stages,
+		lists,
+		n,
+		order: stages.map((_, k) => k).sort((a, b) => Number(first.has(stages[b].name)) - Number(first.has(stages[a].name)) || lists[b].length - lists[a].length || a - b),
+		naming: stages.map((s) => constraints.filter((c) => c.if.stage === s.name || otherStage(c) === s.name))
+	};
+}
+/**
+* This function gives the options of one point of a walk. It fixes the largest stage first. Thus that stage keeps its equal strata, and the constraints limit only the smaller stages.
+* The value `picks[k][i]` is the stratum of the stage `k` for the point `i`. A stage with no open option gets `null`, and the caller rejects that point.
+* The argument `fits` lets a test give a fault. The default is `fitsWalk`.
+*/
+function walkPoint(plan, picks, i, fits = fitsWalk) {
+	const fixed = /* @__PURE__ */ new Map();
+	const out = /* @__PURE__ */ new Map();
+	for (const k of plan.order) {
+		const s = plan.stages[k];
+		const open = plan.lists[k].filter((o) => fits(plan.naming[k], fixed, s.name, o?.id ?? null));
+		const o = open[Math.floor(picks[k][i] * open.length / plan.n)] ?? null;
+		fixed.set(s.name, o?.id ?? null);
+		out.set(s.name, o);
+	}
+	return out;
+}
+export { fitsWalk, holds, walkPlan, walkPoint };
+
+//# sourceMappingURL=space-walk.js.map

package/build/space-walk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"space-walk.js","names":[],"sources":["../src/space-walk.ts"],"sourcesContent":["// The walk draw of a sample of a strategy space (`docs/STRATEGY-SPACE.md`). The package root does not export this file.\nimport type { OptionRef, SpaceConstraint, SpaceStage, StageOption } from \"./strategy-space.ts\";\n\nconst refMatches = (ref: OptionRef, choices: ReadonlyMap<string, string | null>): boolean => (choices.get(ref.stage) ?? null) === ref.option;\n\n/** This function tells if the option choices keep a constraint. */\nexport function holds(c: SpaceConstraint, choices: ReadonlyMap<string, string | null>): boolean {\n  if (!refMatches(c.if, choices)) return true;\n  return \"not\" in c.then ? !refMatches(c.then.not, choices) : refMatches(c.then, choices);\n}\n\nconst otherStage = (c: SpaceConstraint): string => (\"not\" in c.then ? c.then.not.stage : c.then.stage);\n\n/** This function tells if an option of a stage keeps each constraint between that stage and the stages that a walk has fixed. */\nexport function fitsWalk(constraints: readonly SpaceConstraint[], fixed: Map<string, string | null>, stage: string, id: string | null): boolean {\n  fixed.set(stage, id);\n  const ok = constraints.every((c) => !fixed.has(c.if.stage === stage ? otherStage(c) : c.if.stage) || holds(c, fixed));\n  fixed.delete(stage);\n  return ok;\n}\n\n/** The order of the stages of a walk, and the constraints that name each stage. */\nexport interface WalkPlan {\n  /** The stages of the space. */\n  readonly stages: readonly SpaceStage[];\n  /** The options of each stage for a draw. */\n  readonly lists: readonly (readonly (StageOption | null)[])[];\n  /** The indexes of the stages. The stages of `first` come first, in the order of the space. The others follow, from the largest stage to the smallest. */\n  readonly order: readonly number[];\n  /** The constraints that name each stage. */\n  readonly naming: readonly (readonly SpaceConstraint[])[];\n  /** The count of points of a round. */\n  readonly n: number;\n}\n\n/**\n * This function gives the plan of a walk. Stages of equal size keep the order of the space.\n * The stages of `first` go first, for example the stages of the sample option `fixed`. Thus the other stages draw only from the options that keep the constraints with them.\n */\nexport function walkPlan(\n  stages: readonly SpaceStage[],\n  lists: readonly (readonly (StageOption | null)[])[],\n  constraints: readonly SpaceConstraint[],\n  n: number,\n  first: ReadonlySet<string> = new Set(),\n): WalkPlan {\n  return {\n    stages,\n    lists,\n    n,\n    order: stages.map((_, k) => k).sort((a, b) => Number(first.has(stages[b]!.name)) - Number(first.has(stages[a]!.name)) || lists[b]!.length - lists[a]!.length || a - b),\n    naming: stages.map((s) => constraints.filter((c) => c.if.stage === s.name || otherStage(c) === s.name)),\n  };\n}\n\n/**\n * This function gives the options of one point of a walk. It fixes the largest stage first. Thus that stage keeps its equal strata, and the constraints limit only the smaller stages.\n * The value `picks[k][i]` is the stratum of the stage `k` for the point `i`. A stage with no open option gets `null`, and the caller rejects that point.\n * The argument `fits` lets a test give a fault. The default is `fitsWalk`.\n */\nexport function walkPoint(plan: WalkPlan, picks: readonly (readonly number[])[], i: number, fits: typeof fitsWalk = fitsWalk): Map<string, StageOption | null> {\n  const fixed = new Map<string, string | null>();\n  const out = new Map<string, StageOption | null>();\n  for (const k of plan.order) {\n    const s = plan.stages[k]!;\n    const open = plan.lists[k]!.filter((o) => fits(plan.naming[k]!, fixed, s.name, o?.id ?? null));\n    const o = open[Math.floor((picks[k]![i]! * open.length) / plan.n)] ?? null;\n    fixed.set(s.name, o?.id ?? null);\n    out.set(s.name, o);\n  }\n  return out;\n}\n"],"mappings":";AAGA,MAAM,cAAc,KAAgB,aAA0D,QAAQ,IAAI,IAAI,KAAK,KAAK,UAAU,IAAI;;AAGtI,SAAgB,MAAM,GAAoB,SAAsD;CAC9F,IAAI,CAAC,WAAW,EAAE,IAAI,OAAO,GAAG,OAAO;CACvC,OAAO,SAAS,EAAE,OAAO,CAAC,WAAW,EAAE,KAAK,KAAK,OAAO,IAAI,WAAW,EAAE,MAAM,OAAO;AACxF;AAEA,MAAM,cAAc,MAAgC,SAAS,EAAE,OAAO,EAAE,KAAK,IAAI,QAAQ,EAAE,KAAK;;AAGhG,SAAgB,SAAS,aAAyC,OAAmC,OAAe,IAA4B;CAC9I,MAAM,IAAI,OAAO,EAAE;CACnB,MAAM,KAAK,YAAY,OAAO,MAAM,CAAC,MAAM,IAAI,EAAE,GAAG,UAAU,QAAQ,WAAW,CAAC,IAAI,EAAE,GAAG,KAAK,KAAK,MAAM,GAAG,KAAK,CAAC;CACpH,MAAM,OAAO,KAAK;CAClB,OAAO;AACT;;;;;AAoBA,SAAgB,SACd,QACA,OACA,aACA,GACA,wBAA6B,IAAI,IAAI,GAC3B;CACV,OAAO;EACL;EACA;EACA;EACA,OAAO,OAAO,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,OAAO,MAAM,IAAI,OAAO,EAAE,CAAE,IAAI,CAAC,IAAI,OAAO,MAAM,IAAI,OAAO,EAAE,CAAE,IAAI,CAAC,KAAK,MAAM,EAAE,CAAE,SAAS,MAAM,EAAE,CAAE,UAAU,IAAI,CAAC;EACrK,QAAQ,OAAO,KAAK,MAAM,YAAY,QAAQ,MAAM,EAAE,GAAG,UAAU,EAAE,QAAQ,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC;CACxG;AACF;;;;;;AAOA,SAAgB,UAAU,MAAgB,OAAuC,GAAW,OAAwB,UAA2C;CAC7J,MAAM,wBAAQ,IAAI,IAA2B;CAC7C,MAAM,sBAAM,IAAI,IAAgC;CAChD,KAAK,MAAM,KAAK,KAAK,OAAO;EAC1B,MAAM,IAAI,KAAK,OAAO;EACtB,MAAM,OAAO,KAAK,MAAM,EAAE,CAAE,QAAQ,MAAM,KAAK,KAAK,OAAO,IAAK,OAAO,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;EAC7F,MAAM,IAAI,KAAK,KAAK,MAAO,MAAM,EAAE,CAAE,KAAM,KAAK,SAAU,KAAK,CAAC,MAAM;EACtE,MAAM,IAAI,EAAE,MAAM,GAAG,MAAM,IAAI;EAC/B,IAAI,IAAI,EAAE,MAAM,CAAC;CACnB;CACA,OAAO;AACT"}