@cratis/scene.engine 4.2.1 → 4.4.0

package/dist/esm/editing/validateValue.js

@@ -0,0 +1,111 @@
+import { PropertyValueType } from '@cratis/scene.model';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+/**
+ * Checks a value against a property descriptor.
+ *
+ * @param descriptor The property the value is for.
+ * @param value The value to check. `undefined` means "not set", which is fine unless the property is required.
+ * @returns The reason the value is not acceptable, or `undefined` when it is.
+ */ function validateValue(descriptor, value) {
+    const constraints = descriptor.constraints ?? {};
+    if (value === undefined || value === null) {
+        return constraints.required ? 'a value is required' : undefined;
+    }
+    switch(descriptor.valueType){
+        case PropertyValueType.String:
+            {
+                if (typeof value !== 'string') return 'expected a string';
+                if (constraints.minimumLength !== undefined && value.length < constraints.minimumLength) return `must be at least ${constraints.minimumLength} characters`;
+                if (constraints.maximumLength !== undefined && value.length > constraints.maximumLength) return `must be at most ${constraints.maximumLength} characters`;
+                if (constraints.pattern !== undefined && !new RegExp(`^(?:${constraints.pattern})$`).test(value)) return `must match ${constraints.pattern}`;
+                return undefined;
+            }
+        case PropertyValueType.Number:
+            {
+                if (typeof value !== 'number' || !Number.isFinite(value)) return 'expected a number';
+                if (constraints.integer && !Number.isInteger(value)) return 'expected a whole number';
+                if (constraints.minimum !== undefined && value < constraints.minimum) return `must be at least ${constraints.minimum}`;
+                if (constraints.maximum !== undefined && value > constraints.maximum) return `must be at most ${constraints.maximum}`;
+                return undefined;
+            }
+        case PropertyValueType.Boolean:
+            return typeof value === 'boolean' ? undefined : 'expected true or false';
+        case PropertyValueType.Enum:
+            return (descriptor.choices ?? []).some((choice)=>choice.value === value) ? undefined : 'not one of the allowed choices';
+        case PropertyValueType.Icon:
+            if (!isRecord(value) || !isNonEmptyString(value.library) || !isNonEmptyString(value.key)) return 'expected an icon reference with a library and a key';
+            return value.variant === undefined || typeof value.variant === 'string' ? undefined : 'the icon variant must be a string';
+        case PropertyValueType.Destination:
+            if (!isRecord(value) || !isNonEmptyString(value.screen)) return 'expected a destination naming a screen';
+            return value.routeParameterBindings === undefined || isRecord(value.routeParameterBindings) ? undefined : 'routeParameterBindings must be an object';
+        case PropertyValueType.QueryReference:
+            if (isNonEmptyString(value)) return undefined;
+            if (!isRecord(value) || !isNonEmptyString(value.queryId) || !isNonEmptyString(value.query)) return 'expected a query name or a query binding';
+            return Array.isArray(value.arguments) && Array.isArray(value.results) ? undefined : 'a query binding needs arguments and results lists';
+        case PropertyValueType.Collection:
+            return validateCollection(descriptor, value);
+        default:
+            return isRecord(value) || Array.isArray(value) ? undefined : 'expected a structured value';
+    }
+}
+function validateCollection(descriptor, value) {
+    if (!Array.isArray(value)) return 'expected a list';
+    const constraints = descriptor.constraints ?? {};
+    if (constraints.minimumItems !== undefined && value.length < constraints.minimumItems) return `needs at least ${constraints.minimumItems} items`;
+    if (constraints.maximumItems !== undefined && value.length > constraints.maximumItems) return `allows at most ${constraints.maximumItems} items`;
+    const identities = new Set();
+    for (const item of value){
+        if (!isRecord(item) || !isNonEmptyString(item.id)) return 'every item needs an id';
+        if (identities.has(item.id)) return `the item id '${item.id}' is used twice`;
+        identities.add(item.id);
+        const { id: _identity, ...values } = item;
+        const problem = validateItemValues(descriptor.item, values).at(0);
+        if (problem) return `item '${item.id}': ${problem.field} ${problem.problem}`;
+    }
+    return undefined;
+}
+/**
+ * Checks a collection item's field values against the collection's item descriptor.
+ *
+ * @param itemDescriptor What the items look like.
+ * @param values The item's field values, keyed by field path.
+ * @returns Every field that is unknown or has an unacceptable value.
+ */ function validateItemValues(itemDescriptor, values) {
+    const fields = itemDescriptor?.properties ?? [];
+    const problems = [];
+    for (const [field, fieldValue] of Object.entries(values)){
+        const fieldDescriptor = fields.find((candidate)=>candidate.path === field);
+        if (!fieldDescriptor) {
+            problems.push({
+                field,
+                problem: 'is not a field of this collection\'s items'
+            });
+            continue;
+        }
+        const problem = validateValue(fieldDescriptor, fieldValue);
+        if (problem) problems.push({
+            field,
+            problem
+        });
+    }
+    for (const fieldDescriptor of fields){
+        if (fieldDescriptor.constraints?.required && values[fieldDescriptor.path] === undefined) {
+            problems.push({
+                field: fieldDescriptor.path,
+                problem: 'a value is required'
+            });
+        }
+    }
+    return problems;
+}
+
+export { validateItemValues, validateValue };
+//# sourceMappingURL=validateValue.js.map

package/dist/esm/editing/validateValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateValue.js","sources":["../../../editing/validateValue.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { CollectionItemDescriptor, PropertyDescriptor, PropertyValueType } from '@cratis/scene.model';\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n    return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction isNonEmptyString(value: unknown): value is string {\n    return typeof value === 'string' && value.length > 0;\n}\n\n/**\n * Checks a value against a property descriptor.\n *\n * @param descriptor The property the value is for.\n * @param value The value to check. `undefined` means \"not set\", which is fine unless the property is required.\n * @returns The reason the value is not acceptable, or `undefined` when it is.\n */\nexport function validateValue(descriptor: PropertyDescriptor, value: unknown): string | undefined {\n    const constraints = descriptor.constraints ?? {};\n    if (value === undefined || value === null) {\n        return constraints.required ? 'a value is required' : undefined;\n    }\n\n    switch (descriptor.valueType) {\n        case PropertyValueType.String: {\n            if (typeof value !== 'string') return 'expected a string';\n            if (constraints.minimumLength !== undefined && value.length < constraints.minimumLength) return `must be at least ${constraints.minimumLength} characters`;\n            if (constraints.maximumLength !== undefined && value.length > constraints.maximumLength) return `must be at most ${constraints.maximumLength} characters`;\n            if (constraints.pattern !== undefined && !new RegExp(`^(?:${constraints.pattern})$`).test(value)) return `must match ${constraints.pattern}`;\n            return undefined;\n        }\n\n        case PropertyValueType.Number: {\n            if (typeof value !== 'number' || !Number.isFinite(value)) return 'expected a number';\n            if (constraints.integer && !Number.isInteger(value)) return 'expected a whole number';\n            if (constraints.minimum !== undefined && value < constraints.minimum) return `must be at least ${constraints.minimum}`;\n            if (constraints.maximum !== undefined && value > constraints.maximum) return `must be at most ${constraints.maximum}`;\n            return undefined;\n        }\n\n        case PropertyValueType.Boolean:\n            return typeof value === 'boolean' ? undefined : 'expected true or false';\n\n        case PropertyValueType.Enum:\n            return (descriptor.choices ?? []).some(choice => choice.value === value) ? undefined : 'not one of the allowed choices';\n\n        case PropertyValueType.Icon:\n            if (!isRecord(value) || !isNonEmptyString(value.library) || !isNonEmptyString(value.key)) return 'expected an icon reference with a library and a key';\n            return value.variant === undefined || typeof value.variant === 'string' ? undefined : 'the icon variant must be a string';\n\n        case PropertyValueType.Destination:\n            if (!isRecord(value) || !isNonEmptyString(value.screen)) return 'expected a destination naming a screen';\n            return value.routeParameterBindings === undefined || isRecord(value.routeParameterBindings)\n                ? undefined\n                : 'routeParameterBindings must be an object';\n\n        case PropertyValueType.QueryReference:\n            if (isNonEmptyString(value)) return undefined;\n            if (!isRecord(value) || !isNonEmptyString(value.queryId) || !isNonEmptyString(value.query)) return 'expected a query name or a query binding';\n            return Array.isArray(value.arguments) && Array.isArray(value.results) ? undefined : 'a query binding needs arguments and results lists';\n\n        case PropertyValueType.Collection:\n            return validateCollection(descriptor, value);\n\n        default:\n            return isRecord(value) || Array.isArray(value) ? undefined : 'expected a structured value';\n    }\n}\n\nfunction validateCollection(descriptor: PropertyDescriptor, value: unknown): string | undefined {\n    if (!Array.isArray(value)) return 'expected a list';\n    const constraints = descriptor.constraints ?? {};\n    if (constraints.minimumItems !== undefined && value.length < constraints.minimumItems) return `needs at least ${constraints.minimumItems} items`;\n    if (constraints.maximumItems !== undefined && value.length > constraints.maximumItems) return `allows at most ${constraints.maximumItems} items`;\n\n    const identities = new Set<string>();\n    for (const item of value) {\n        if (!isRecord(item) || !isNonEmptyString(item.id)) return 'every item needs an id';\n        if (identities.has(item.id)) return `the item id '${item.id}' is used twice`;\n        identities.add(item.id);\n\n        const { id: _identity, ...values } = item;\n        const problem = validateItemValues(descriptor.item, values).at(0);\n        if (problem) return `item '${item.id}': ${problem.field} ${problem.problem}`;\n    }\n\n    return undefined;\n}\n\n/**\n * One field of a collection item that does not fit its descriptor.\n */\nexport interface ItemFieldProblem {\n    field: string;\n    problem: string;\n}\n\n/**\n * Checks a collection item's field values against the collection's item descriptor.\n *\n * @param itemDescriptor What the items look like.\n * @param values The item's field values, keyed by field path.\n * @returns Every field that is unknown or has an unacceptable value.\n */\nexport function validateItemValues(itemDescriptor: CollectionItemDescriptor | undefined, values: Record<string, unknown>): ItemFieldProblem[] {\n    const fields = itemDescriptor?.properties ?? [];\n    const problems: ItemFieldProblem[] = [];\n\n    for (const [field, fieldValue] of Object.entries(values)) {\n        const fieldDescriptor = fields.find(candidate => candidate.path === field);\n        if (!fieldDescriptor) {\n            problems.push({ field, problem: 'is not a field of this collection\\'s items' });\n            continue;\n        }\n\n        const problem = validateValue(fieldDescriptor, fieldValue);\n        if (problem) problems.push({ field, problem });\n    }\n\n    for (const fieldDescriptor of fields) {\n        if (fieldDescriptor.constraints?.required && values[fieldDescriptor.path] === undefined) {\n            problems.push({ field: fieldDescriptor.path, problem: 'a value is required' });\n        }\n    }\n\n    return problems;\n}\n"],"names":["isRecord","value","Array","isArray","isNonEmptyString","length","validateValue","descriptor","constraints","undefined","required","valueType","PropertyValueType","String","minimumLength","maximumLength","pattern","RegExp","test","Number","isFinite","integer","isInteger","minimum","maximum","Boolean","Enum","choices","some","choice","Icon","library","key","variant","Destination","screen","routeParameterBindings","QueryReference","queryId","query","arguments","results","Collection","validateCollection","minimumItems","maximumItems","identities","Set","item","id","has","add","_identity","values","problem","validateItemValues","at","field","itemDescriptor","fields","properties","problems","fieldValue","Object","entries","fieldDescriptor","find","candidate","path","push"],"mappings":";;AAAA;AACA;AAIA,SAASA,SAASC,KAAc,EAAA;IAC5B,OAAOA,KAAAA,KAAU,QAAQ,OAAOA,KAAAA,KAAU,YAAY,CAACC,KAAAA,CAAMC,OAAO,CAACF,KAAAA,CAAAA;AACzE;AAEA,SAASG,iBAAiBH,KAAc,EAAA;AACpC,IAAA,OAAO,OAAOA,KAAAA,KAAU,QAAA,IAAYA,KAAAA,CAAMI,MAAM,GAAG,CAAA;AACvD;AAEA;;;;;;AAMC,IACM,SAASC,aAAAA,CAAcC,UAA8B,EAAEN,KAAc,EAAA;AACxE,IAAA,MAAMO,WAAAA,GAAcD,UAAAA,CAAWC,WAAW,IAAI,EAAC;IAC/C,IAAIP,KAAAA,KAAUQ,SAAAA,IAAaR,KAAAA,KAAU,IAAA,EAAM;QACvC,OAAOO,WAAAA,CAAYE,QAAQ,GAAG,qBAAA,GAAwBD,SAAAA;AAC1D,IAAA;AAEA,IAAA,OAAQF,WAAWI,SAAS;AACxB,QAAA,KAAKC,kBAAkBC,MAAM;AAAE,YAAA;gBAC3B,IAAI,OAAOZ,KAAAA,KAAU,QAAA,EAAU,OAAO,mBAAA;AACtC,gBAAA,IAAIO,YAAYM,aAAa,KAAKL,aAAaR,KAAAA,CAAMI,MAAM,GAAGG,WAAAA,CAAYM,aAAa,EAAE,OAAO,CAAC,iBAAiB,EAAEN,YAAYM,aAAa,CAAC,WAAW,CAAC;AAC1J,gBAAA,IAAIN,YAAYO,aAAa,KAAKN,aAAaR,KAAAA,CAAMI,MAAM,GAAGG,WAAAA,CAAYO,aAAa,EAAE,OAAO,CAAC,gBAAgB,EAAEP,YAAYO,aAAa,CAAC,WAAW,CAAC;gBACzJ,IAAIP,WAAAA,CAAYQ,OAAO,KAAKP,SAAAA,IAAa,CAAC,IAAIQ,MAAAA,CAAO,CAAC,IAAI,EAAET,WAAAA,CAAYQ,OAAO,CAAC,EAAE,CAAC,CAAA,CAAEE,IAAI,CAACjB,KAAAA,CAAAA,EAAQ,OAAO,CAAC,WAAW,EAAEO,WAAAA,CAAYQ,OAAO,CAAA,CAAE;gBAC5I,OAAOP,SAAAA;AACX,YAAA;AAEA,QAAA,KAAKG,kBAAkBO,MAAM;AAAE,YAAA;gBAC3B,IAAI,OAAOlB,UAAU,QAAA,IAAY,CAACkB,OAAOC,QAAQ,CAACnB,QAAQ,OAAO,mBAAA;gBACjE,IAAIO,WAAAA,CAAYa,OAAO,IAAI,CAACF,OAAOG,SAAS,CAACrB,QAAQ,OAAO,yBAAA;AAC5D,gBAAA,IAAIO,WAAAA,CAAYe,OAAO,KAAKd,SAAAA,IAAaR,QAAQO,WAAAA,CAAYe,OAAO,EAAE,OAAO,CAAC,iBAAiB,EAAEf,WAAAA,CAAYe,OAAO,CAAA,CAAE;AACtH,gBAAA,IAAIf,WAAAA,CAAYgB,OAAO,KAAKf,SAAAA,IAAaR,QAAQO,WAAAA,CAAYgB,OAAO,EAAE,OAAO,CAAC,gBAAgB,EAAEhB,WAAAA,CAAYgB,OAAO,CAAA,CAAE;gBACrH,OAAOf,SAAAA;AACX,YAAA;AAEA,QAAA,KAAKG,kBAAkBa,OAAO;YAC1B,OAAO,OAAOxB,KAAAA,KAAU,SAAA,GAAYQ,SAAAA,GAAY,wBAAA;AAEpD,QAAA,KAAKG,kBAAkBc,IAAI;AACvB,YAAA,OAAO,CAACnB,UAAAA,CAAWoB,OAAO,IAAI,EAAE,EAAEC,IAAI,CAACC,CAAAA,MAAAA,GAAUA,MAAAA,CAAO5B,KAAK,KAAKA,SAASQ,SAAAA,GAAY,gCAAA;AAE3F,QAAA,KAAKG,kBAAkBkB,IAAI;AACvB,YAAA,IAAI,CAAC9B,QAAAA,CAASC,KAAAA,CAAAA,IAAU,CAACG,gBAAAA,CAAiBH,KAAAA,CAAM8B,OAAO,CAAA,IAAK,CAAC3B,gBAAAA,CAAiBH,KAAAA,CAAM+B,GAAG,GAAG,OAAO,qDAAA;YACjG,OAAO/B,KAAAA,CAAMgC,OAAO,KAAKxB,SAAAA,IAAa,OAAOR,KAAAA,CAAMgC,OAAO,KAAK,QAAA,GAAWxB,SAAAA,GAAY,mCAAA;AAE1F,QAAA,KAAKG,kBAAkBsB,WAAW;YAC9B,IAAI,CAAClC,SAASC,KAAAA,CAAAA,IAAU,CAACG,iBAAiBH,KAAAA,CAAMkC,MAAM,GAAG,OAAO,wCAAA;YAChE,OAAOlC,KAAAA,CAAMmC,sBAAsB,KAAK3B,SAAAA,IAAaT,SAASC,KAAAA,CAAMmC,sBAAsB,IACpF3B,SAAAA,GACA,0CAAA;AAEV,QAAA,KAAKG,kBAAkByB,cAAc;YACjC,IAAIjC,gBAAAA,CAAiBH,QAAQ,OAAOQ,SAAAA;AACpC,YAAA,IAAI,CAACT,QAAAA,CAASC,KAAAA,CAAAA,IAAU,CAACG,gBAAAA,CAAiBH,KAAAA,CAAMqC,OAAO,CAAA,IAAK,CAAClC,gBAAAA,CAAiBH,KAAAA,CAAMsC,KAAK,GAAG,OAAO,0CAAA;AACnG,YAAA,OAAOrC,KAAAA,CAAMC,OAAO,CAACF,KAAAA,CAAMuC,SAAS,CAAA,IAAKtC,KAAAA,CAAMC,OAAO,CAACF,KAAAA,CAAMwC,OAAO,CAAA,GAAIhC,SAAAA,GAAY,mDAAA;AAExF,QAAA,KAAKG,kBAAkB8B,UAAU;AAC7B,YAAA,OAAOC,mBAAmBpC,UAAAA,EAAYN,KAAAA,CAAAA;AAE1C,QAAA;AACI,YAAA,OAAOD,SAASC,KAAAA,CAAAA,IAAUC,KAAAA,CAAMC,OAAO,CAACF,SAASQ,SAAAA,GAAY,6BAAA;AACrE;AACJ;AAEA,SAASkC,kBAAAA,CAAmBpC,UAA8B,EAAEN,KAAc,EAAA;AACtE,IAAA,IAAI,CAACC,KAAAA,CAAMC,OAAO,CAACF,QAAQ,OAAO,iBAAA;AAClC,IAAA,MAAMO,WAAAA,GAAcD,UAAAA,CAAWC,WAAW,IAAI,EAAC;AAC/C,IAAA,IAAIA,YAAYoC,YAAY,KAAKnC,aAAaR,KAAAA,CAAMI,MAAM,GAAGG,WAAAA,CAAYoC,YAAY,EAAE,OAAO,CAAC,eAAe,EAAEpC,YAAYoC,YAAY,CAAC,MAAM,CAAC;AAChJ,IAAA,IAAIpC,YAAYqC,YAAY,KAAKpC,aAAaR,KAAAA,CAAMI,MAAM,GAAGG,WAAAA,CAAYqC,YAAY,EAAE,OAAO,CAAC,eAAe,EAAErC,YAAYqC,YAAY,CAAC,MAAM,CAAC;AAEhJ,IAAA,MAAMC,aAAa,IAAIC,GAAAA,EAAAA;IACvB,KAAK,MAAMC,QAAQ/C,KAAAA,CAAO;QACtB,IAAI,CAACD,SAASgD,IAAAA,CAAAA,IAAS,CAAC5C,iBAAiB4C,IAAAA,CAAKC,EAAE,GAAG,OAAO,wBAAA;AAC1D,QAAA,IAAIH,UAAAA,CAAWI,GAAG,CAACF,IAAAA,CAAKC,EAAE,CAAA,EAAG,OAAO,CAAC,aAAa,EAAED,IAAAA,CAAKC,EAAE,CAAC,eAAe,CAAC;QAC5EH,UAAAA,CAAWK,GAAG,CAACH,IAAAA,CAAKC,EAAE,CAAA;AAEtB,QAAA,MAAM,EAAEA,EAAAA,EAAIG,SAAS,EAAE,GAAGC,QAAQ,GAAGL,IAAAA;AACrC,QAAA,MAAMM,UAAUC,kBAAAA,CAAmBhD,UAAAA,CAAWyC,IAAI,EAAEK,MAAAA,CAAAA,CAAQG,EAAE,CAAC,CAAA,CAAA;AAC/D,QAAA,IAAIF,SAAS,OAAO,CAAC,MAAM,EAAEN,KAAKC,EAAE,CAAC,GAAG,EAAEK,QAAQG,KAAK,CAAC,CAAC,EAAEH,OAAAA,CAAQA,OAAO,CAAA,CAAE;AAChF,IAAA;IAEA,OAAO7C,SAAAA;AACX;AAUA;;;;;;AAMC,IACM,SAAS8C,kBAAAA,CAAmBG,cAAoD,EAAEL,MAA+B,EAAA;IACpH,MAAMM,MAAAA,GAASD,cAAAA,EAAgBE,UAAAA,IAAc,EAAE;AAC/C,IAAA,MAAMC,WAA+B,EAAE;IAEvC,KAAK,MAAM,CAACJ,KAAAA,EAAOK,UAAAA,CAAW,IAAIC,MAAAA,CAAOC,OAAO,CAACX,MAAAA,CAAAA,CAAS;QACtD,MAAMY,eAAAA,GAAkBN,OAAOO,IAAI,CAACC,CAAAA,SAAAA,GAAaA,SAAAA,CAAUC,IAAI,KAAKX,KAAAA,CAAAA;AACpE,QAAA,IAAI,CAACQ,eAAAA,EAAiB;AAClBJ,YAAAA,QAAAA,CAASQ,IAAI,CAAC;AAAEZ,gBAAAA,KAAAA;gBAAOH,OAAAA,EAAS;AAA6C,aAAA,CAAA;AAC7E,YAAA;AACJ,QAAA;QAEA,MAAMA,OAAAA,GAAUhD,cAAc2D,eAAAA,EAAiBH,UAAAA,CAAAA;QAC/C,IAAIR,OAAAA,EAASO,QAAAA,CAASQ,IAAI,CAAC;AAAEZ,YAAAA,KAAAA;AAAOH,YAAAA;AAAQ,SAAA,CAAA;AAChD,IAAA;IAEA,KAAK,MAAMW,mBAAmBN,MAAAA,CAAQ;QAClC,IAAIM,eAAAA,CAAgBzD,WAAW,EAAEE,QAAAA,IAAY2C,MAAM,CAACY,eAAAA,CAAgBG,IAAI,CAAC,KAAK3D,SAAAA,EAAW;AACrFoD,YAAAA,QAAAA,CAASQ,IAAI,CAAC;AAAEZ,gBAAAA,KAAAA,EAAOQ,gBAAgBG,IAAI;gBAAEd,OAAAA,EAAS;AAAsB,aAAA,CAAA;AAChF,QAAA;AACJ,IAAA;IAEA,OAAOO,QAAAA;AACX;;"}

package/dist/esm/icons/EffectiveIconCatalog.d.ts

@@ -0,0 +1,25 @@
+import { IconEntry, IconReference } from '@cratis/scene.model';
+import { EffectiveIconEntry } from './EffectiveIconEntry';
+import { IconCatalogSource } from './IconCatalogSource';
+import { IconDiagnostic } from './IconDiagnostic';
+import { IconLibraryResolution } from './IconLibraryResolution';
+import { IconQuery } from './IconQuery';
+import { IconResolution } from './IconResolution';
+import { IconSearchResult } from './IconSearchResult';
+import { ResolvedIconLibrary } from './ResolvedIconLibrary';
+export declare class EffectiveIconCatalog {
+    #private;
+    readonly resolution: IconLibraryResolution;
+    constructor(resolution: IconLibraryResolution, sources: IconCatalogSource[]);
+    get libraries(): ResolvedIconLibrary[];
+    get diagnostics(): IconDiagnostic[];
+    isLoaded(library: string): boolean;
+    entriesOf(library: string): Promise<IconEntry[] | undefined>;
+    search(query?: IconQuery): Promise<IconSearchResult>;
+    findByName(name: string): Promise<EffectiveIconEntry[]>;
+    categories(library?: string): Promise<string[]>;
+    resolve(reference: IconReference): Promise<IconResolution>;
+    lookup(reference: IconReference): IconResolution | undefined;
+    load(library?: string): Promise<IconDiagnostic[]>;
+}
+//# sourceMappingURL=EffectiveIconCatalog.d.ts.map

package/dist/esm/icons/EffectiveIconCatalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectiveIconCatalog.d.ts","sourceRoot":"","sources":["../../../icons/EffectiveIconCatalog.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAuB,MAAM,qBAAqB,CAAC;AACpF,OAAO,EAAE,kBAAkB,EAAqB,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAY5D,qBAAa,oBAAoB;;IAUjB,QAAQ,CAAC,UAAU,EAAE,qBAAqB;IAAtD,YAAqB,UAAU,EAAE,qBAAqB,EAAE,OAAO,EAAE,iBAAiB,EAAE,EAEnF;IAKD,IAAI,SAAS,IAAI,mBAAmB,EAAE,CAErC;IAKD,IAAI,WAAW,IAAI,cAAc,EAAE,CAElC;IAKD,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEjC;IAQK,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,GAAG,SAAS,CAAC,CAiBjE;IAKK,MAAM,CAAC,KAAK,GAAE,SAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAmB7D;IAOK,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAI5D;IAKK,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAGpD;IAKK,OAAO,CAAC,SAAS,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC,CAQ/D;IAWD,MAAM,CAAC,SAAS,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,CAsB3D;IAMK,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAItD;CAkBJ"}

package/dist/esm/icons/EffectiveIconCatalog.js

@@ -0,0 +1,210 @@
+import { formatIconReference } from '@cratis/scene.model';
+import { referencesOfEntry } from './EffectiveIconEntry.js';
+import { matchesIconQuery } from './matchesIconQuery.js';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The icons a profile can actually use: the active libraries from {@link resolveIconLibraries}, with their
+ * catalogs loaded on demand.
+ *
+ * Opening it costs nothing - no catalog is read until a query or a lookup needs that library, and a
+ * query narrowed to one library reads only that one. A catalog is loaded once and kept; a load that
+ * fails is not kept, so the next call tries again. Everything that goes wrong is reported as an
+ * {@link IconDiagnostic}; nothing is ever answered with a different icon than the one asked for.
+ */ class EffectiveIconCatalog {
+    resolution;
+    #sources;
+    #loads = new Map();
+    #loadedEntries = new Map();
+    /**
+     * @param resolution The active libraries and the problems found with them.
+     * @param sources The catalog source of each library; a library with none is active but reports
+     * 'catalog-unavailable' when its icons are needed.
+     */ constructor(resolution, sources){
+        this.resolution = resolution;
+        this.#sources = new Map(sources.map((source)=>[
+                source.library,
+                source
+            ]));
+    }
+    /**
+     * The active libraries, with provenance.
+     */ get libraries() {
+        return this.resolution.libraries;
+    }
+    /**
+     * Problems with the libraries themselves, known without loading any catalog.
+     */ get diagnostics() {
+        return this.resolution.diagnostics;
+    }
+    /**
+     * Whether a library's catalog has been read yet.
+     */ isLoaded(library) {
+        return this.#loadedEntries.has(library);
+    }
+    /**
+     * The entries of one library, loading its catalog if this is the first time it is needed.
+     * Resolves to `undefined` when the library is not active.
+     *
+     * @throws Whatever the library's source throws, or an Error when an active library has no source.
+     */ async entriesOf(library) {
+        if (!this.libraries.some((resolved)=>resolved.library === library)) return undefined;
+        let load = this.#loads.get(library);
+        if (!load) {
+            const source = this.#sources.get(library);
+            if (!source) throw new Error(`The icon library '${library}' is active but has no catalog source`);
+            load = source.loadEntries();
+            this.#loads.set(library, load);
+            load.then((entries)=>this.#loadedEntries.set(library, entries), ()=>this.#loads.delete(library));
+        }
+        return load;
+    }
+    /**
+     * Searches the catalogs of the libraries the query covers - all of them, or the one it names.
+     */ async search(query = {}) {
+        const covered = this.libraries.filter((resolved)=>query.library === undefined || resolved.library === query.library);
+        const outcomes = await Promise.all(covered.map(async (resolved)=>this.#entriesOrDiagnostic(resolved)));
+        const entries = [];
+        const diagnostics = [];
+        outcomes.forEach((outcome, position)=>{
+            const library = covered[position];
+            if ('diagnostic' in outcome) {
+                diagnostics.push(outcome.diagnostic);
+                return;
+            }
+            for (const entry of outcome.entries.filter((candidate)=>matchesIconQuery(candidate, query))){
+                entries.push({
+                    library,
+                    entry,
+                    references: referencesOfEntry(library.library, entry)
+                });
+            }
+        });
+        return {
+            entries,
+            diagnostics
+        };
+    }
+    /**
+     * Every active library's icons whose name or key is exactly `name` (ignoring case) - the several
+     * candidates a bare legacy icon name could have meant. More than one is a real answer, not a tie to
+     * break: it is the author's decision which library the icon comes from.
+     */ async findByName(name) {
+        const wanted = name.trim().toLowerCase();
+        const { entries } = await this.search({});
+        return entries.filter(({ entry })=>entry.key.toLowerCase() === wanted || entry.name.toLowerCase() === wanted);
+    }
+    /**
+     * The categories in use, sorted, across all libraries or one.
+     */ async categories(library) {
+        const { entries } = await this.search({
+            library
+        });
+        return [
+            ...new Set(entries.flatMap(({ entry })=>entry.categories))
+        ].sort();
+    }
+    /**
+     * Looks a reference up: the icon it names, or exactly why there is none.
+     */ async resolve(reference) {
+        const library = this.libraries.find((resolved)=>resolved.library === reference.library);
+        if (library && !this.isLoaded(library.library) && !this.#incompatibility(library)) {
+            const outcome = await this.#entriesOrDiagnostic(library);
+            if ('diagnostic' in outcome) return {
+                isResolved: false,
+                reference,
+                diagnostic: {
+                    ...outcome.diagnostic,
+                    reference
+                }
+            };
+        }
+        return this.lookup(reference);
+    }
+    /**
+     * Looks a reference up without loading anything, for callers that cannot wait - an edit is applied
+     * synchronously. Resolves everything that is decidable from what is already known: a library that is not
+     * active, one at an incompatible version, and - once the library's catalog has been loaded - a missing
+     * icon or variant.
+     *
+     * @returns The resolution, or `undefined` when the library is active but its catalog has not been loaded,
+     * so nothing can be said about the icon yet. Call {@link load} first to make the answer definite.
+     */ lookup(reference) {
+        const library = this.libraries.find((resolved)=>resolved.library === reference.library);
+        if (!library) {
+            return this.#unresolved(reference, 'missing-library', `The icon library '${reference.library}' is not active in this profile`);
+        }
+        const incompatible = this.#incompatibility(library);
+        if (incompatible) return {
+            isResolved: false,
+            reference,
+            diagnostic: {
+                ...incompatible,
+                reference
+            }
+        };
+        const entries = this.#loadedEntries.get(library.library);
+        if (!entries) return undefined;
+        const entry = entries.find((candidate)=>candidate.key === reference.key);
+        if (!entry) {
+            return this.#unresolved(reference, 'missing-icon', `The icon library '${library.library}' has no icon '${reference.key}'`);
+        }
+        if (reference.variant !== undefined && !(entry.variants ?? []).includes(reference.variant)) {
+            return this.#unresolved(reference, 'missing-variant', `The icon '${formatIconReference({
+                library: library.library,
+                key: entry.key
+            })}' has no '${reference.variant}' variant`);
+        }
+        return {
+            isResolved: true,
+            reference,
+            library,
+            entry
+        };
+    }
+    /**
+     * Loads the catalogs of one library, or of every active library, so that {@link lookup} can answer
+     * definitely. Libraries whose catalog cannot be loaded are reported, not thrown.
+     */ async load(library) {
+        const covered = this.libraries.filter((resolved)=>library === undefined || resolved.library === library);
+        const outcomes = await Promise.all(covered.map(async (resolved)=>this.#entriesOrDiagnostic(resolved)));
+        return outcomes.flatMap((outcome)=>'diagnostic' in outcome ? [
+                outcome.diagnostic
+            ] : []);
+    }
+    #incompatibility(library) {
+        return this.diagnostics.find((diagnostic)=>diagnostic.kind === 'incompatible-version' && diagnostic.library === library.library);
+    }
+    async #entriesOrDiagnostic(library) {
+        try {
+            return {
+                entries: await this.entriesOf(library.library) ?? []
+            };
+        } catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            return {
+                diagnostic: {
+                    kind: 'catalog-unavailable',
+                    library: library.library,
+                    message: `The catalog of '${library.library}' could not be loaded: ${reason}`
+                }
+            };
+        }
+    }
+    #unresolved(reference, kind, message) {
+        return {
+            isResolved: false,
+            reference,
+            diagnostic: {
+                kind,
+                library: reference.library,
+                message,
+                reference
+            }
+        };
+    }
+}
+
+export { EffectiveIconCatalog };
+//# sourceMappingURL=EffectiveIconCatalog.js.map

package/dist/esm/icons/EffectiveIconCatalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectiveIconCatalog.js","sources":["../../../icons/EffectiveIconCatalog.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { IconEntry, IconReference, formatIconReference } from '@cratis/scene.model';\nimport { EffectiveIconEntry, referencesOfEntry } from './EffectiveIconEntry';\nimport { IconCatalogSource } from './IconCatalogSource';\nimport { IconDiagnostic } from './IconDiagnostic';\nimport { IconLibraryResolution } from './IconLibraryResolution';\nimport { IconQuery } from './IconQuery';\nimport { IconResolution } from './IconResolution';\nimport { IconSearchResult } from './IconSearchResult';\nimport { ResolvedIconLibrary } from './ResolvedIconLibrary';\nimport { matchesIconQuery } from './matchesIconQuery';\n\n/**\n * The icons a profile can actually use: the active libraries from {@link resolveIconLibraries}, with their\n * catalogs loaded on demand.\n *\n * Opening it costs nothing - no catalog is read until a query or a lookup needs that library, and a\n * query narrowed to one library reads only that one. A catalog is loaded once and kept; a load that\n * fails is not kept, so the next call tries again. Everything that goes wrong is reported as an\n * {@link IconDiagnostic}; nothing is ever answered with a different icon than the one asked for.\n */\nexport class EffectiveIconCatalog {\n    readonly #sources: Map<string, IconCatalogSource>;\n    readonly #loads = new Map<string, Promise<IconEntry[]>>();\n    readonly #loadedEntries = new Map<string, IconEntry[]>();\n\n    /**\n     * @param resolution The active libraries and the problems found with them.\n     * @param sources The catalog source of each library; a library with none is active but reports\n     * 'catalog-unavailable' when its icons are needed.\n     */\n    constructor(readonly resolution: IconLibraryResolution, sources: IconCatalogSource[]) {\n        this.#sources = new Map(sources.map((source) => [source.library, source]));\n    }\n\n    /**\n     * The active libraries, with provenance.\n     */\n    get libraries(): ResolvedIconLibrary[] {\n        return this.resolution.libraries;\n    }\n\n    /**\n     * Problems with the libraries themselves, known without loading any catalog.\n     */\n    get diagnostics(): IconDiagnostic[] {\n        return this.resolution.diagnostics;\n    }\n\n    /**\n     * Whether a library's catalog has been read yet.\n     */\n    isLoaded(library: string): boolean {\n        return this.#loadedEntries.has(library);\n    }\n\n    /**\n     * The entries of one library, loading its catalog if this is the first time it is needed.\n     * Resolves to `undefined` when the library is not active.\n     *\n     * @throws Whatever the library's source throws, or an Error when an active library has no source.\n     */\n    async entriesOf(library: string): Promise<IconEntry[] | undefined> {\n        if (!this.libraries.some((resolved) => resolved.library === library)) return undefined;\n\n        let load = this.#loads.get(library);\n        if (!load) {\n            const source = this.#sources.get(library);\n            if (!source) throw new Error(`The icon library '${library}' is active but has no catalog source`);\n\n            load = source.loadEntries();\n            this.#loads.set(library, load);\n            load.then(\n                (entries) => this.#loadedEntries.set(library, entries),\n                () => this.#loads.delete(library)\n            );\n        }\n\n        return load;\n    }\n\n    /**\n     * Searches the catalogs of the libraries the query covers - all of them, or the one it names.\n     */\n    async search(query: IconQuery = {}): Promise<IconSearchResult> {\n        const covered = this.libraries.filter((resolved) => query.library === undefined || resolved.library === query.library);\n        const outcomes = await Promise.all(covered.map(async (resolved) => this.#entriesOrDiagnostic(resolved)));\n\n        const entries: EffectiveIconEntry[] = [];\n        const diagnostics: IconDiagnostic[] = [];\n        outcomes.forEach((outcome, position) => {\n            const library = covered[position];\n            if ('diagnostic' in outcome) {\n                diagnostics.push(outcome.diagnostic);\n                return;\n            }\n\n            for (const entry of outcome.entries.filter((candidate) => matchesIconQuery(candidate, query))) {\n                entries.push({ library, entry, references: referencesOfEntry(library.library, entry) });\n            }\n        });\n\n        return { entries, diagnostics };\n    }\n\n    /**\n     * Every active library's icons whose name or key is exactly `name` (ignoring case) - the several\n     * candidates a bare legacy icon name could have meant. More than one is a real answer, not a tie to\n     * break: it is the author's decision which library the icon comes from.\n     */\n    async findByName(name: string): Promise<EffectiveIconEntry[]> {\n        const wanted = name.trim().toLowerCase();\n        const { entries } = await this.search({});\n        return entries.filter(({ entry }) => entry.key.toLowerCase() === wanted || entry.name.toLowerCase() === wanted);\n    }\n\n    /**\n     * The categories in use, sorted, across all libraries or one.\n     */\n    async categories(library?: string): Promise<string[]> {\n        const { entries } = await this.search({ library });\n        return [...new Set(entries.flatMap(({ entry }) => entry.categories))].sort();\n    }\n\n    /**\n     * Looks a reference up: the icon it names, or exactly why there is none.\n     */\n    async resolve(reference: IconReference): Promise<IconResolution> {\n        const library = this.libraries.find((resolved) => resolved.library === reference.library);\n        if (library && !this.isLoaded(library.library) && !this.#incompatibility(library)) {\n            const outcome = await this.#entriesOrDiagnostic(library);\n            if ('diagnostic' in outcome) return { isResolved: false, reference, diagnostic: { ...outcome.diagnostic, reference } };\n        }\n\n        return this.lookup(reference) as IconResolution;\n    }\n\n    /**\n     * Looks a reference up without loading anything, for callers that cannot wait - an edit is applied\n     * synchronously. Resolves everything that is decidable from what is already known: a library that is not\n     * active, one at an incompatible version, and - once the library's catalog has been loaded - a missing\n     * icon or variant.\n     *\n     * @returns The resolution, or `undefined` when the library is active but its catalog has not been loaded,\n     * so nothing can be said about the icon yet. Call {@link load} first to make the answer definite.\n     */\n    lookup(reference: IconReference): IconResolution | undefined {\n        const library = this.libraries.find((resolved) => resolved.library === reference.library);\n        if (!library) {\n            return this.#unresolved(reference, 'missing-library', `The icon library '${reference.library}' is not active in this profile`);\n        }\n\n        const incompatible = this.#incompatibility(library);\n        if (incompatible) return { isResolved: false, reference, diagnostic: { ...incompatible, reference } };\n\n        const entries = this.#loadedEntries.get(library.library);\n        if (!entries) return undefined;\n\n        const entry = entries.find((candidate) => candidate.key === reference.key);\n        if (!entry) {\n            return this.#unresolved(reference, 'missing-icon', `The icon library '${library.library}' has no icon '${reference.key}'`);\n        }\n\n        if (reference.variant !== undefined && !(entry.variants ?? []).includes(reference.variant)) {\n            return this.#unresolved(reference, 'missing-variant', `The icon '${formatIconReference({ library: library.library, key: entry.key })}' has no '${reference.variant}' variant`);\n        }\n\n        return { isResolved: true, reference, library, entry };\n    }\n\n    /**\n     * Loads the catalogs of one library, or of every active library, so that {@link lookup} can answer\n     * definitely. Libraries whose catalog cannot be loaded are reported, not thrown.\n     */\n    async load(library?: string): Promise<IconDiagnostic[]> {\n        const covered = this.libraries.filter((resolved) => library === undefined || resolved.library === library);\n        const outcomes = await Promise.all(covered.map(async (resolved) => this.#entriesOrDiagnostic(resolved)));\n        return outcomes.flatMap((outcome) => ('diagnostic' in outcome ? [outcome.diagnostic] : []));\n    }\n\n    #incompatibility(library: ResolvedIconLibrary): IconDiagnostic | undefined {\n        return this.diagnostics.find((diagnostic) => diagnostic.kind === 'incompatible-version' && diagnostic.library === library.library);\n    }\n\n    async #entriesOrDiagnostic(library: ResolvedIconLibrary): Promise<{ entries: IconEntry[] } | { diagnostic: IconDiagnostic }> {\n        try {\n            return { entries: (await this.entriesOf(library.library)) ?? [] };\n        } catch (error) {\n            const reason = error instanceof Error ? error.message : String(error);\n            return { diagnostic: { kind: 'catalog-unavailable', library: library.library, message: `The catalog of '${library.library}' could not be loaded: ${reason}` } };\n        }\n    }\n\n    #unresolved(reference: IconReference, kind: IconDiagnostic['kind'], message: string): IconResolution & { isResolved: false } {\n        return { isResolved: false, reference, diagnostic: { kind, library: reference.library, message, reference } };\n    }\n}\n"],"names":["EffectiveIconCatalog","Map","resolution","sources","map","source","library","libraries","diagnostics","isLoaded","has","entriesOf","some","resolved","undefined","load","get","Error","loadEntries","set","then","entries","delete","search","query","covered","filter","outcomes","Promise","all","forEach","outcome","position","push","diagnostic","entry","candidate","matchesIconQuery","references","referencesOfEntry","findByName","name","wanted","trim","toLowerCase","key","categories","Set","flatMap","sort","resolve","reference","find","isResolved","lookup","incompatible","variant","variants","includes","formatIconReference","kind","error","reason","message","String"],"mappings":";;;;AAAA;AACA;AAaA;;;;;;;;AAQC,IACM,MAAMA,oBAAAA,CAAAA;;AACA,IAAA,QAAQ;IACR,MAAM,GAAG,IAAIC,GAAAA,EAAAA;IACb,cAAc,GAAG,IAAIA,GAAAA,EAAAA;AAE9B;;;;AAIC,QACD,WAAA,CAAqBC,UAAiC,EAAEC,OAA4B,CAAE;aAAjED,UAAAA,GAAAA,UAAAA;QACjB,IAAI,CAAC,QAAQ,GAAG,IAAID,IAAIE,OAAAA,CAAQC,GAAG,CAAC,CAACC,MAAAA,GAAW;AAACA,gBAAAA,MAAAA,CAAOC,OAAO;AAAED,gBAAAA;AAAO,aAAA,CAAA,CAAA;AAC5E,IAAA;AAEA;;AAEC,QACD,IAAIE,SAAAA,GAAmC;AACnC,QAAA,OAAO,IAAI,CAACL,UAAU,CAACK,SAAS;AACpC,IAAA;AAEA;;AAEC,QACD,IAAIC,WAAAA,GAAgC;AAChC,QAAA,OAAO,IAAI,CAACN,UAAU,CAACM,WAAW;AACtC,IAAA;AAEA;;QAGAC,QAAAA,CAASH,OAAe,EAAW;AAC/B,QAAA,OAAO,IAAI,CAAC,cAAc,CAACI,GAAG,CAACJ,OAAAA,CAAAA;AACnC,IAAA;AAEA;;;;;QAMA,MAAMK,SAAAA,CAAUL,OAAe,EAAoC;AAC/D,QAAA,IAAI,CAAC,IAAI,CAACC,SAAS,CAACK,IAAI,CAAC,CAACC,QAAAA,GAAaA,QAAAA,CAASP,OAAO,KAAKA,UAAU,OAAOQ,SAAAA;AAE7E,QAAA,IAAIC,OAAO,IAAI,CAAC,MAAM,CAACC,GAAG,CAACV,OAAAA,CAAAA;AAC3B,QAAA,IAAI,CAACS,IAAAA,EAAM;AACP,YAAA,MAAMV,SAAS,IAAI,CAAC,QAAQ,CAACW,GAAG,CAACV,OAAAA,CAAAA;YACjC,IAAI,CAACD,MAAAA,EAAQ,MAAM,IAAIY,KAAAA,CAAM,CAAC,kBAAkB,EAAEX,OAAAA,CAAQ,qCAAqC,CAAC,CAAA;AAEhGS,YAAAA,IAAAA,GAAOV,OAAOa,WAAW,EAAA;AACzB,YAAA,IAAI,CAAC,MAAM,CAACC,GAAG,CAACb,OAAAA,EAASS,IAAAA,CAAAA;YACzBA,IAAAA,CAAKK,IAAI,CACL,CAACC,OAAAA,GAAY,IAAI,CAAC,cAAc,CAACF,GAAG,CAACb,OAAAA,EAASe,OAAAA,CAAAA,EAC9C,IAAM,IAAI,CAAC,MAAM,CAACC,MAAM,CAAChB,OAAAA,CAAAA,CAAAA;AAEjC,QAAA;QAEA,OAAOS,IAAAA;AACX,IAAA;AAEA;;AAEC,QACD,MAAMQ,MAAAA,CAAOC,KAAAA,GAAmB,EAAE,EAA6B;AAC3D,QAAA,MAAMC,UAAU,IAAI,CAAClB,SAAS,CAACmB,MAAM,CAAC,CAACb,QAAAA,GAAaW,KAAAA,CAAMlB,OAAO,KAAKQ,SAAAA,IAAaD,SAASP,OAAO,KAAKkB,MAAMlB,OAAO,CAAA;AACrH,QAAA,MAAMqB,QAAAA,GAAW,MAAMC,OAAAA,CAAQC,GAAG,CAACJ,OAAAA,CAAQrB,GAAG,CAAC,OAAOS,QAAAA,GAAa,IAAI,CAAC,oBAAoB,CAACA,QAAAA,CAAAA,CAAAA,CAAAA;AAE7F,QAAA,MAAMQ,UAAgC,EAAE;AACxC,QAAA,MAAMb,cAAgC,EAAE;QACxCmB,QAAAA,CAASG,OAAO,CAAC,CAACC,OAAAA,EAASC,QAAAA,GAAAA;YACvB,MAAM1B,OAAAA,GAAUmB,OAAO,CAACO,QAAAA,CAAS;AACjC,YAAA,IAAI,gBAAgBD,OAAAA,EAAS;gBACzBvB,WAAAA,CAAYyB,IAAI,CAACF,OAAAA,CAAQG,UAAU,CAAA;AACnC,gBAAA;AACJ,YAAA;YAEA,KAAK,MAAMC,KAAAA,IAASJ,OAAAA,CAAQV,OAAO,CAACK,MAAM,CAAC,CAACU,SAAAA,GAAcC,gBAAAA,CAAiBD,SAAAA,EAAWZ,KAAAA,CAAAA,CAAAA,CAAS;AAC3FH,gBAAAA,OAAAA,CAAQY,IAAI,CAAC;AAAE3B,oBAAAA,OAAAA;AAAS6B,oBAAAA,KAAAA;oBAAOG,UAAAA,EAAYC,iBAAAA,CAAkBjC,OAAAA,CAAQA,OAAO,EAAE6B,KAAAA;AAAO,iBAAA,CAAA;AACzF,YAAA;AACJ,QAAA,CAAA,CAAA;QAEA,OAAO;AAAEd,YAAAA,OAAAA;AAASb,YAAAA;AAAY,SAAA;AAClC,IAAA;AAEA;;;;QAKA,MAAMgC,UAAAA,CAAWC,IAAY,EAAiC;AAC1D,QAAA,MAAMC,MAAAA,GAASD,IAAAA,CAAKE,IAAI,EAAA,CAAGC,WAAW,EAAA;QACtC,MAAM,EAAEvB,OAAO,EAAE,GAAG,MAAM,IAAI,CAACE,MAAM,CAAC,EAAC,CAAA;AACvC,QAAA,OAAOF,QAAQK,MAAM,CAAC,CAAC,EAAES,KAAK,EAAE,GAAKA,KAAAA,CAAMU,GAAG,CAACD,WAAW,EAAA,KAAOF,MAAAA,IAAUP,MAAMM,IAAI,CAACG,WAAW,EAAA,KAAOF,MAAAA,CAAAA;AAC5G,IAAA;AAEA;;QAGA,MAAMI,UAAAA,CAAWxC,OAAgB,EAAqB;QAClD,MAAM,EAAEe,OAAO,EAAE,GAAG,MAAM,IAAI,CAACE,MAAM,CAAC;AAAEjB,YAAAA;AAAQ,SAAA,CAAA;QAChD,OAAO;eAAI,IAAIyC,GAAAA,CAAI1B,OAAAA,CAAQ2B,OAAO,CAAC,CAAC,EAAEb,KAAK,EAAE,GAAKA,KAAAA,CAAMW,UAAU,CAAA;AAAG,SAAA,CAACG,IAAI,EAAA;AAC9E,IAAA;AAEA;;QAGA,MAAMC,OAAAA,CAAQC,SAAwB,EAA2B;AAC7D,QAAA,MAAM7C,OAAAA,GAAU,IAAI,CAACC,SAAS,CAAC6C,IAAI,CAAC,CAACvC,QAAAA,GAAaA,QAAAA,CAASP,OAAO,KAAK6C,UAAU7C,OAAO,CAAA;AACxF,QAAA,IAAIA,OAAAA,IAAW,CAAC,IAAI,CAACG,QAAQ,CAACH,OAAAA,CAAQA,OAAO,CAAA,IAAK,CAAC,IAAI,CAAC,gBAAgB,CAACA,OAAAA,CAAAA,EAAU;AAC/E,YAAA,MAAMyB,UAAU,MAAM,IAAI,CAAC,oBAAoB,CAACzB,OAAAA,CAAAA;YAChD,IAAI,YAAA,IAAgByB,SAAS,OAAO;gBAAEsB,UAAAA,EAAY,KAAA;AAAOF,gBAAAA,SAAAA;gBAAWjB,UAAAA,EAAY;AAAE,oBAAA,GAAGH,QAAQG,UAAU;AAAEiB,oBAAAA;AAAU;AAAE,aAAA;AACzH,QAAA;QAEA,OAAO,IAAI,CAACG,MAAM,CAACH,SAAAA,CAAAA;AACvB,IAAA;AAEA;;;;;;;;QASAG,MAAAA,CAAOH,SAAwB,EAA8B;AACzD,QAAA,MAAM7C,OAAAA,GAAU,IAAI,CAACC,SAAS,CAAC6C,IAAI,CAAC,CAACvC,QAAAA,GAAaA,QAAAA,CAASP,OAAO,KAAK6C,UAAU7C,OAAO,CAAA;AACxF,QAAA,IAAI,CAACA,OAAAA,EAAS;AACV,YAAA,OAAO,IAAI,CAAC,WAAW,CAAC6C,SAAAA,EAAW,iBAAA,EAAmB,CAAC,kBAAkB,EAAEA,SAAAA,CAAU7C,OAAO,CAAC,+BAA+B,CAAC,CAAA;AACjI,QAAA;AAEA,QAAA,MAAMiD,YAAAA,GAAe,IAAI,CAAC,gBAAgB,CAACjD,OAAAA,CAAAA;AAC3C,QAAA,IAAIiD,cAAc,OAAO;YAAEF,UAAAA,EAAY,KAAA;AAAOF,YAAAA,SAAAA;YAAWjB,UAAAA,EAAY;AAAE,gBAAA,GAAGqB,YAAY;AAAEJ,gBAAAA;AAAU;AAAE,SAAA;QAEpG,MAAM9B,OAAAA,GAAU,IAAI,CAAC,cAAc,CAACL,GAAG,CAACV,OAAAA,CAAQA,OAAO,CAAA;QACvD,IAAI,CAACe,SAAS,OAAOP,SAAAA;QAErB,MAAMqB,KAAAA,GAAQd,OAAAA,CAAQ+B,IAAI,CAAC,CAAChB,YAAcA,SAAAA,CAAUS,GAAG,KAAKM,SAAAA,CAAUN,GAAG,CAAA;AACzE,QAAA,IAAI,CAACV,KAAAA,EAAO;AACR,YAAA,OAAO,IAAI,CAAC,WAAW,CAACgB,SAAAA,EAAW,gBAAgB,CAAC,kBAAkB,EAAE7C,OAAAA,CAAQA,OAAO,CAAC,eAAe,EAAE6C,UAAUN,GAAG,CAAC,CAAC,CAAC,CAAA;AAC7H,QAAA;AAEA,QAAA,IAAIM,UAAUK,OAAO,KAAK1C,SAAAA,IAAa,CAAC,CAACqB,KAAAA,CAAMsB,QAAQ,IAAI,EAAE,EAAEC,QAAQ,CAACP,SAAAA,CAAUK,OAAO,CAAA,EAAG;YACxF,OAAO,IAAI,CAAC,WAAW,CAACL,WAAW,iBAAA,EAAmB,CAAC,UAAU,EAAEQ,mBAAAA,CAAoB;AAAErD,gBAAAA,OAAAA,EAASA,QAAQA,OAAO;AAAEuC,gBAAAA,GAAAA,EAAKV,MAAMU;AAAI,aAAA,CAAA,CAAG,UAAU,EAAEM,SAAAA,CAAUK,OAAO,CAAC,SAAS,CAAC,CAAA;AACjL,QAAA;QAEA,OAAO;YAAEH,UAAAA,EAAY,IAAA;AAAMF,YAAAA,SAAAA;AAAW7C,YAAAA,OAAAA;AAAS6B,YAAAA;AAAM,SAAA;AACzD,IAAA;AAEA;;;QAIA,MAAMpB,IAAAA,CAAKT,OAAgB,EAA6B;AACpD,QAAA,MAAMmB,OAAAA,GAAU,IAAI,CAAClB,SAAS,CAACmB,MAAM,CAAC,CAACb,QAAAA,GAAaP,OAAAA,KAAYQ,SAAAA,IAAaD,QAAAA,CAASP,OAAO,KAAKA,OAAAA,CAAAA;AAClG,QAAA,MAAMqB,QAAAA,GAAW,MAAMC,OAAAA,CAAQC,GAAG,CAACJ,OAAAA,CAAQrB,GAAG,CAAC,OAAOS,QAAAA,GAAa,IAAI,CAAC,oBAAoB,CAACA,QAAAA,CAAAA,CAAAA,CAAAA;AAC7F,QAAA,OAAOc,SAASqB,OAAO,CAAC,CAACjB,OAAAA,GAAa,gBAAgBA,OAAAA,GAAU;AAACA,gBAAAA,OAAAA,CAAQG;AAAW,aAAA,GAAG,EAAE,CAAA;AAC7F,IAAA;IAEA,gBAAgB,CAAC5B,OAA4B,EAAA;AACzC,QAAA,OAAO,IAAI,CAACE,WAAW,CAAC4C,IAAI,CAAC,CAAClB,UAAAA,GAAeA,UAAAA,CAAW0B,IAAI,KAAK,sBAAA,IAA0B1B,UAAAA,CAAW5B,OAAO,KAAKA,QAAQA,OAAO,CAAA;AACrI,IAAA;IAEA,MAAM,oBAAoB,CAACA,OAA4B,EAAA;QACnD,IAAI;YACA,OAAO;gBAAEe,OAAAA,EAAU,MAAM,IAAI,CAACV,SAAS,CAACL,OAAAA,CAAQA,OAAO,CAAA,IAAM;AAAG,aAAA;AACpE,QAAA,CAAA,CAAE,OAAOuD,KAAAA,EAAO;AACZ,YAAA,MAAMC,SAASD,KAAAA,YAAiB5C,KAAAA,GAAQ4C,KAAAA,CAAME,OAAO,GAAGC,MAAAA,CAAOH,KAAAA,CAAAA;YAC/D,OAAO;gBAAE3B,UAAAA,EAAY;oBAAE0B,IAAAA,EAAM,qBAAA;AAAuBtD,oBAAAA,OAAAA,EAASA,QAAQA,OAAO;oBAAEyD,OAAAA,EAAS,CAAC,gBAAgB,EAAEzD,OAAAA,CAAQA,OAAO,CAAC,uBAAuB,EAAEwD,MAAAA,CAAAA;AAAS;AAAE,aAAA;AAClK,QAAA;AACJ,IAAA;AAEA,IAAA,WAAW,CAACX,SAAwB,EAAES,IAA4B,EAAEG,OAAe,EAAA;QAC/E,OAAO;YAAEV,UAAAA,EAAY,KAAA;AAAOF,YAAAA,SAAAA;YAAWjB,UAAAA,EAAY;AAAE0B,gBAAAA,IAAAA;AAAMtD,gBAAAA,OAAAA,EAAS6C,UAAU7C,OAAO;AAAEyD,gBAAAA,OAAAA;AAASZ,gBAAAA;AAAU;AAAE,SAAA;AAChH,IAAA;AACJ;;"}

package/dist/esm/icons/EffectiveIconEntry.d.ts

@@ -0,0 +1,9 @@
+import { IconEntry, IconReference } from '@cratis/scene.model';
+import { ResolvedIconLibrary } from './ResolvedIconLibrary';
+export interface EffectiveIconEntry {
+    library: ResolvedIconLibrary;
+    entry: IconEntry;
+    references: IconReference[];
+}
+export declare function referencesOfEntry(library: string, entry: IconEntry): IconReference[];
+//# sourceMappingURL=EffectiveIconEntry.d.ts.map

package/dist/esm/icons/EffectiveIconEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectiveIconEntry.d.ts","sourceRoot":"","sources":["../../../icons/EffectiveIconEntry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAM5D,MAAM,WAAW,kBAAkB;IAI/B,OAAO,EAAE,mBAAmB,CAAC;IAK7B,KAAK,EAAE,SAAS,CAAC;IAKjB,UAAU,EAAE,aAAa,EAAE,CAAC;CAC/B;AAKD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,aAAa,EAAE,CAKpF"}

package/dist/esm/icons/EffectiveIconEntry.js

@@ -0,0 +1,20 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/**
+ * The references that name an entry of a library: one per variant, or one without a variant.
+ */ function referencesOfEntry(library, entry) {
+    const variants = entry.variants ?? [];
+    return variants.length === 0 ? [
+        {
+            library,
+            key: entry.key
+        }
+    ] : variants.map((variant)=>({
+            library,
+            key: entry.key,
+            variant
+        }));
+}
+
+export { referencesOfEntry };
+//# sourceMappingURL=EffectiveIconEntry.js.map

package/dist/esm/icons/EffectiveIconEntry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectiveIconEntry.js","sources":["../../../icons/EffectiveIconEntry.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { IconEntry, IconReference } from '@cratis/scene.model';\nimport { ResolvedIconLibrary } from './ResolvedIconLibrary';\n\n/**\n * An icon as a picker shows it: the catalog entry, the library that provides it (so provenance and\n * attribution are one step away), and the references that name it.\n */\nexport interface EffectiveIconEntry {\n    /**\n     * The active library that provides the icon.\n     */\n    library: ResolvedIconLibrary;\n\n    /**\n     * The catalog entry.\n     */\n    entry: IconEntry;\n\n    /**\n     * One reference per variant the icon exists in, or the single variant-less reference when it has none.\n     */\n    references: IconReference[];\n}\n\n/**\n * The references that name an entry of a library: one per variant, or one without a variant.\n */\nexport function referencesOfEntry(library: string, entry: IconEntry): IconReference[] {\n    const variants = entry.variants ?? [];\n    return variants.length === 0\n        ? [{ library, key: entry.key }]\n        : variants.map((variant) => ({ library, key: entry.key, variant }));\n}\n"],"names":["referencesOfEntry","library","entry","variants","length","key","map","variant"],"mappings":"AAAA;AACA;AA0BA;;AAEC,IACM,SAASA,iBAAAA,CAAkBC,OAAe,EAAEC,KAAgB,EAAA;AAC/D,IAAA,MAAMC,QAAAA,GAAWD,KAAAA,CAAMC,QAAQ,IAAI,EAAE;IACrC,OAAOA,QAAAA,CAASC,MAAM,KAAK,CAAA,GACrB;AAAC,QAAA;AAAEH,YAAAA,OAAAA;AAASI,YAAAA,GAAAA,EAAKH,MAAMG;AAAI;AAAE,KAAA,GAC7BF,QAAAA,CAASG,GAAG,CAAC,CAACC,WAAa;AAAEN,YAAAA,OAAAA;AAASI,YAAAA,GAAAA,EAAKH,MAAMG,GAAG;AAAEE,YAAAA;SAAQ,CAAA,CAAA;AACxE;;"}

package/dist/esm/icons/IconCatalogSource.d.ts

@@ -0,0 +1,6 @@
+import { IconEntry } from '@cratis/scene.model';
+export interface IconCatalogSource {
+    library: string;
+    loadEntries(): Promise<IconEntry[]>;
+}
+//# sourceMappingURL=IconCatalogSource.d.ts.map

package/dist/esm/icons/IconCatalogSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconCatalogSource.d.ts","sourceRoot":"","sources":["../../../icons/IconCatalogSource.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAShD,MAAM,WAAW,iBAAiB;IAI9B,OAAO,EAAE,MAAM,CAAC;IAKhB,WAAW,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;CACvC"}

package/dist/esm/icons/IconCatalogSource.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IconCatalogSource.js.map

package/dist/esm/icons/IconCatalogSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconCatalogSource.js","sourceRoot":"","sources":["../../../icons/IconCatalogSource.ts"],"names":[],"mappings":""}

package/dist/esm/icons/IconDiagnostic.d.ts

@@ -0,0 +1,9 @@
+import { IconReference } from '@cratis/scene.model';
+export type IconDiagnosticKind = 'missing-library' | 'missing-icon' | 'missing-variant' | 'incompatible-version' | 'catalog-unavailable';
+export interface IconDiagnostic {
+    kind: IconDiagnosticKind;
+    library: string;
+    message: string;
+    reference?: IconReference;
+}
+//# sourceMappingURL=IconDiagnostic.d.ts.map

package/dist/esm/icons/IconDiagnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconDiagnostic.d.ts","sourceRoot":"","sources":["../../../icons/IconDiagnostic.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAMpD,MAAM,MAAM,kBAAkB,GAExB,iBAAiB,GAEjB,cAAc,GAEd,iBAAiB,GAEjB,sBAAsB,GAEtB,qBAAqB,CAAC;AAK5B,MAAM,WAAW,cAAc;IAI3B,IAAI,EAAE,kBAAkB,CAAC;IAKzB,OAAO,EAAE,MAAM,CAAC;IAKhB,OAAO,EAAE,MAAM,CAAC;IAKhB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC7B"}

package/dist/esm/icons/IconDiagnostic.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IconDiagnostic.js.map

package/dist/esm/icons/IconDiagnostic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconDiagnostic.js","sourceRoot":"","sources":["../../../icons/IconDiagnostic.ts"],"names":[],"mappings":""}

package/dist/esm/icons/IconImpactReport.d.ts

@@ -0,0 +1,18 @@
+import { EffectiveIconEntry } from './EffectiveIconEntry';
+import { IconDiagnostic } from './IconDiagnostic';
+import { IconUsage } from './IconUsage';
+export interface AffectedIconUsage {
+    usage: IconUsage;
+    diagnostic: IconDiagnostic;
+    wasResolvable: boolean;
+}
+export interface LegacyIconUsage {
+    usage: IconUsage;
+    candidates: EffectiveIconEntry[];
+}
+export interface IconImpactReport {
+    affected: AffectedIconUsage[];
+    unaffectedCount: number;
+    legacy: LegacyIconUsage[];
+}
+//# sourceMappingURL=IconImpactReport.d.ts.map

package/dist/esm/icons/IconImpactReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconImpactReport.d.ts","sourceRoot":"","sources":["../../../icons/IconImpactReport.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKxC,MAAM,WAAW,iBAAiB;IAI9B,KAAK,EAAE,SAAS,CAAC;IAKjB,UAAU,EAAE,cAAc,CAAC;IAM3B,aAAa,EAAE,OAAO,CAAC;CAC1B;AAKD,MAAM,WAAW,eAAe;IAI5B,KAAK,EAAE,SAAS,CAAC;IAMjB,UAAU,EAAE,kBAAkB,EAAE,CAAC;CACpC;AAKD,MAAM,WAAW,gBAAgB;IAI7B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;IAK9B,eAAe,EAAE,MAAM,CAAC;IAKxB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC7B"}

package/dist/esm/icons/IconImpactReport.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IconImpactReport.js.map

package/dist/esm/icons/IconImpactReport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconImpactReport.js","sourceRoot":"","sources":["../../../icons/IconImpactReport.ts"],"names":[],"mappings":""}

package/dist/esm/icons/IconLibraryResolution.d.ts

@@ -0,0 +1,7 @@
+import { IconDiagnostic } from './IconDiagnostic';
+import { ResolvedIconLibrary } from './ResolvedIconLibrary';
+export interface IconLibraryResolution {
+    libraries: ResolvedIconLibrary[];
+    diagnostics: IconDiagnostic[];
+}
+//# sourceMappingURL=IconLibraryResolution.d.ts.map

package/dist/esm/icons/IconLibraryResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconLibraryResolution.d.ts","sourceRoot":"","sources":["../../../icons/IconLibraryResolution.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAK5D,MAAM,WAAW,qBAAqB;IAMlC,SAAS,EAAE,mBAAmB,EAAE,CAAC;IAKjC,WAAW,EAAE,cAAc,EAAE,CAAC;CACjC"}

package/dist/esm/icons/IconLibraryResolution.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IconLibraryResolution.js.map

package/dist/esm/icons/IconLibraryResolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconLibraryResolution.js","sourceRoot":"","sources":["../../../icons/IconLibraryResolution.ts"],"names":[],"mappings":""}

package/dist/esm/icons/IconQuery.d.ts

@@ -0,0 +1,7 @@
+export interface IconQuery {
+    text?: string;
+    library?: string;
+    category?: string;
+    variant?: string;
+}
+//# sourceMappingURL=IconQuery.d.ts.map

package/dist/esm/icons/IconQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconQuery.d.ts","sourceRoot":"","sources":["../../../icons/IconQuery.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,SAAS;IAItB,IAAI,CAAC,EAAE,MAAM,CAAC;IAKd,OAAO,CAAC,EAAE,MAAM,CAAC;IAKjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAKlB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/dist/esm/icons/IconQuery.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IconQuery.js.map

package/dist/esm/icons/IconQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconQuery.js","sourceRoot":"","sources":["../../../icons/IconQuery.ts"],"names":[],"mappings":""}

package/dist/esm/icons/IconResolution.d.ts

@@ -0,0 +1,14 @@
+import { IconEntry, IconReference } from '@cratis/scene.model';
+import { IconDiagnostic } from './IconDiagnostic';
+import { ResolvedIconLibrary } from './ResolvedIconLibrary';
+export type IconResolution = {
+    isResolved: true;
+    reference: IconReference;
+    library: ResolvedIconLibrary;
+    entry: IconEntry;
+} | {
+    isResolved: false;
+    reference: IconReference;
+    diagnostic: IconDiagnostic;
+};
+//# sourceMappingURL=IconResolution.d.ts.map

package/dist/esm/icons/IconResolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconResolution.d.ts","sourceRoot":"","sources":["../../../icons/IconResolution.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAM5D,MAAM,MAAM,cAAc,GACpB;IAEI,UAAU,EAAE,IAAI,CAAC;IACjB,SAAS,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,KAAK,EAAE,SAAS,CAAC;CACpB,GACD;IAEI,UAAU,EAAE,KAAK,CAAC;IAClB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,cAAc,CAAC;CAC9B,CAAC"}

package/dist/esm/icons/IconResolution.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IconResolution.js.map

package/dist/esm/icons/IconResolution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconResolution.js","sourceRoot":"","sources":["../../../icons/IconResolution.ts"],"names":[],"mappings":""}

package/dist/esm/icons/IconSearchResult.d.ts

@@ -0,0 +1,7 @@
+import { EffectiveIconEntry } from './EffectiveIconEntry';
+import { IconDiagnostic } from './IconDiagnostic';
+export interface IconSearchResult {
+    entries: EffectiveIconEntry[];
+    diagnostics: IconDiagnostic[];
+}
+//# sourceMappingURL=IconSearchResult.d.ts.map

package/dist/esm/icons/IconSearchResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IconSearchResult.d.ts","sourceRoot":"","sources":["../../../icons/IconSearchResult.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKlD,MAAM,WAAW,gBAAgB;IAI7B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAM9B,WAAW,EAAE,cAAc,EAAE,CAAC;CACjC"}

package/dist/esm/icons/IconSearchResult.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IconSearchResult.js.map