milsymbol-sidc 0.2.0 → 0.4.0

package/README.md

@@ -1,5 +1,11 @@
 # milsymbol-sidc
 
+[![CI](https://github.com/psylsph/milsymbol-sidc/actions/workflows/ci.yml/badge.svg)](https://github.com/psylsph/milsymbol-sidc/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/milsymbol-sidc.svg)](https://www.npmjs.com/package/milsymbol-sidc)
+[![npm downloads](https://img.shields.io/npm/dm/milsymbol-sidc.svg)](https://www.npmjs.com/package/milsymbol-sidc)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-%E2%89%A55.7-blue?logo=typescript&logoColor=white)](https://www.typescriptlang.org/)
+
 A fluent TypeScript builder for **20-character numeric SIDC strings** — the
 symbol identification code format used by [MIL-STD-2525E](https://en.wikipedia.org/wiki/MIL-STD-2525)
 and [APP-6](https://en.wikipedia.org/wiki/NATO_Joint_Military_Symbology) — made
@@ -7,6 +13,7 @@ for constructing symbols with the
 [milsymbol](https://github.com/spatialillusions/milsymbol) library.
 
 ```ts
+import ms from "milsymbol";
 import { Sidc, StandardIdentity, SymbolSet } from "milsymbol-sidc";
 
 const sidc = new Sidc()
@@ -23,15 +30,18 @@ new ms.Symbol(sidc).asSVG(); // friendly land unit icon
 - **Validated output** — invalid values throw; inconsistent combinations warn
   (or throw in `strict` mode), using the same rules milsymbol applies when it
   parses a SIDC.
-- **milsymbol-ready** — positions 8–20 are zero-filled so every generated
-  string is accepted by `new ms.Symbol(...)` out of the box.
+- **milsymbol-ready** — every generated 20-character string is accepted by
+  milsymbol's numeric parser. Full rendering depends on the entity and
+  modifier codes you supply, exactly as it does for any raw SIDC.
 
-> **Coverage:** positions 1–7 of the numeric SIDC (version, context, standard
-> identity, symbol set, status). Positions 8–20 (HQ/task force/dummy, echelon,
-> entity code, sector modifiers) are reserved for future releases.
+> **Coverage:** complete structural encoding for positions 1–20 of the numeric
+> SIDC. Positions 8–10 have named universal codes; positions 11–20 accept
+> validated raw entity and modifier codes. A membership-only code catalog ships
+> behind the `milsymbol-sidc/catalogs` subpath; semantic names remain future work.
 
 ## Installation
 
+Published on npm as [`milsymbol-sidc`](https://www.npmjs.com/package/milsymbol-sidc).
 Requires Node.js >= 18.
 
 ```bash
@@ -42,6 +52,15 @@ yarn add milsymbol-sidc
 pnpm add milsymbol-sidc
 ```
 
+The rendering examples use [`milsymbol`](https://github.com/spatialillusions/milsymbol)
+to draw the generated SIDC. It is **not** a dependency of this package —
+`milsymbol-sidc` has zero runtime dependencies — so install it alongside when
+you want to render symbols:
+
+```bash
+npm install milsymbol
+```
+
 The package ships ESM with bundled TypeScript declarations (`dist/`).
 
 ## Quick start
@@ -73,6 +92,8 @@ The builder is **immutable**: each setter returns a new instance, so a base
 configuration can be safely reused:
 
 ```ts
+import { Sidc, Standard, StandardIdentity } from "milsymbol-sidc";
+
 const base = new Sidc({ standard: Standard.App6 });
 
 const friendly = base.identity(StandardIdentity.Friend).toString();
@@ -82,24 +103,33 @@ const hostile = base.identity(StandardIdentity.SuspectJoker).toString();
 
 ## Anatomy of the generated SIDC
 
-```
-1 3 0 3 1 0 | 0 0 0 0 0 0 0 0 0 0 0 0 0
-└─┬─┘ │ │ └─┬─┘ └──────────┬───────────┘
-  │   │ │   │              zero-filled (future fields)
-  │   │ │   └ status (7)
-  │   │ └ symbol set (5-6)
-  │   └ standard identity (4)
-  └ context (3)
-  version (1-2)
+```text
+13 0 3 10 0 2 16 123456 78 90
+│  │ │ │  │ │ │  │      │  │
+│  │ │ │  │ │ │  │      │  └   modifier 2 (19–20)
+│  │ │ │  │ │ │  │      └  │   modifier 1 (17–18)
+│  │ │ │  │ │ │  └      │  │   entity code (11–16)
+│  │ │ │  │ │ └  │      │  │   amplifier (9–10)
+│  │ │ │  │ └ │  │      │  │   HQ/task force/feint-dummy (8)
+│  │ │ │  └ │ │  │      │  │   status (7)
+│  │ │ └  │ │ │  │      │  │   symbol set (5–6)
+│  │ └ │  │ │ │  │      │  │   standard identity (4)
+│  └ │ │  │ │ │  │      │  │   context (3)
+└  │ │ │  │ │ │  │      │  │   version / edition (1–2)
 ```
 
-| Position | Field | Enum |
+| Position | Field | API |
 | -------- | ------------------ | ----------------- |
-| 1–2 | Version / edition | `Version` |
-| 3 | Context | `Context` |
-| 4 | Standard identity | `StandardIdentity` |
-| 5–6 | Symbol set | `SymbolSet` |
-| 7 | Status / condition | `Status` |
+| 1–2 | Version / edition | `Version`, `version()` |
+| 3 | Context | `Context`, `context()` |
+| 4 | Standard identity | `StandardIdentity`, `identity()` |
+| 5–6 | Symbol set | `SymbolSet`, `symbolSet()` |
+| 7 | Status / condition | `Status`, `status()` |
+| 8 | HQ/task force/feint-dummy | `HqTaskForceDummy`, `hqTaskForceDummy()` |
+| 9–10 | Amplifier | `Amplifier`, `amplifier()` |
+| 11–16 | Entity code | `entity()` — six raw digits |
+| 17–18 | Modifier 1 | `modifier1()` — two raw digits |
+| 19–20 | Modifier 2 | `modifier2()` — two raw digits |
 
 ## API
 
@@ -113,6 +143,7 @@ Present. This remains the default for backward compatibility; configure
 | ------ | ---- | ------- | ----------- |
 | `strict` | `boolean` | `false` | Throw on invalid field combinations during `toString()` instead of warning. Invalid values always throw immediately regardless of this flag. |
 | `standard` | `Standard` | Not configured (2525E behavior) | Select a standard family. `App6` defaults the version to APP-6 E (`"14"`); `MilStd2525` defaults it to MIL-STD-2525E (`"13"`). Explicit configuration also checks that later version choices belong to the selected family. |
+| `onWarning` | `(problem: SidcProblem) => void` | `console.warn` | Receive non-fatal problems instead of writing to the console. `strict: true` still throws instead of reporting. |
 
 ### Methods
 
@@ -126,7 +157,20 @@ All setters validate their argument and return a new immutable `Sidc`.
 | `identity(i)` | Position 4 | A `StandardIdentity` constant |
 | `symbolSet(s)` | Positions 5–6 | A `SymbolSet` constant or any two-digit string |
 | `status(s)` | Position 7 | A `Status` constant |
+| `hqTaskForceDummy(v)` | Position 8 | An `HqTaskForceDummy` constant |
+| `amplifier(v)` | Positions 9–10 | An `Amplifier` constant |
+| `entity(v)` | Positions 11–16 | Any six-digit string; symbol-set-specific catalogs are not included |
+| `modifier1(v)` | Positions 17–18 | Any two-digit string; symbol-set-specific catalogs are not included |
+| `modifier2(v)` | Positions 19–20 | Any two-digit string; symbol-set-specific catalogs are not included |
 | `toString()` | — | Validates combinations and renders the 20-character SIDC |
+| `problems()` | — | Structured list of non-fatal problems; never throws |
+| `isValid()` | — | `true` when `problems()` is empty |
+| `with(fields)` | — | Applies a partial field record immutably; validates like the setters |
+| `clone()` | — | Copies the fields into an independent builder |
+| `equals(other)` | — | Compares encoded fields, ignoring `strict` and `standard` |
+| `toObject()` / `toJSON()` | — | Plain, serializable snapshot of every encoded field |
+| `Sidc.parse(s, options?)` | — | Parses a 20-character numeric SIDC; throws when invalid |
+| `Sidc.tryParse(s, options?)` | — | Parses a SIDC or returns `undefined` |
 
 ### Enum reference
 
@@ -140,6 +184,63 @@ same constant can configure both libraries.
 | `MilStd2525` | `"2525"` | US MIL-STD-2525 (**default behavior when omitted**) |
 | `App6` | `"APP6"` | NATO APP-6 |
 
+#### `HqTaskForceDummy`
+
+Position 8 values identify headquarters, task force, and feint/dummy variants.
+
+| Constant | Code | Meaning |
+| -------- | ---- | ------- |
+| `None` | `"0"` | None / not applicable |
+| `FeintDummy` | `"1"` | Feint/dummy |
+| `Headquarters` | `"2"` | Headquarters |
+| `FeintDummyHeadquarters` | `"3"` | Feint/dummy headquarters |
+| `TaskForce` | `"4"` | Task force |
+| `FeintDummyTaskForce` | `"5"` | Feint/dummy task force |
+| `TaskForceHeadquarters` | `"6"` | Task-force headquarters |
+| `FeintDummyTaskForceHeadquarters` | `"7"` | Feint/dummy task-force headquarters |
+
+#### `Amplifier`
+
+Position 9–10 values identify echelon, mobility, leadership, or auxiliary
+amplifiers. `None` writes the zero/no-amplifier code `"00"`.
+
+| Constant | Code | Meaning |
+| -------- | ---- | ------- |
+| `None` | `"00"` | None / not specified |
+| `TeamCrew` | `"11"` | Team/crew |
+| `Squad` | `"12"` | Squad |
+| `Section` | `"13"` | Section |
+| `PlatoonDetachment` | `"14"` | Platoon/detachment |
+| `CompanyBatteryTroop` | `"15"` | Company/battery/troop |
+| `BattalionSquadron` | `"16"` | Battalion/squadron |
+| `RegimentGroup` | `"17"` | Regiment/group |
+| `Brigade` | `"18"` | Brigade |
+| `Division` | `"21"` | Division |
+| `CorpsMef` | `"22"` | Corps/MEF |
+| `Army` | `"23"` | Army |
+| `ArmyGroupFront` | `"24"` | Army group/front |
+| `RegionTheater` | `"25"` | Region/theater |
+| `Command` | `"26"` | Command |
+| `WheeledLimitedCrossCountry` | `"31"` | Wheeled, limited cross-country |
+| `WheeledCrossCountry` | `"32"` | Wheeled, cross-country |
+| `Tracked` | `"33"` | Tracked |
+| `WheeledTrackedCombination` | `"34"` | Wheeled and tracked combination |
+| `Towed` | `"35"` | Towed |
+| `Rail` | `"36"` | Rail |
+| `PackAnimals` | `"37"` | Pack animals |
+| `OverSnowPrimeMover` | `"41"` | Over snow, prime mover |
+| `Sled` | `"42"` | Sled |
+| `Barge` | `"51"` | Barge |
+| `Amphibious` | `"52"` | Amphibious |
+| `ShortTowedArray` | `"61"` | Short towed array |
+| `LongTowedArray` | `"62"` | Long towed array |
+| `LeaderIndividual` | `"71"` | Leader individual |
+| `DeputyIndividual` | `"72"` | Deputy individual |
+
+Entity and modifier setters intentionally accept raw digit strings so callers
+can use codes specific to their symbol set and edition. They validate width and
+ASCII digits but do not validate catalog membership.
+
 #### `Version`
 
 | Constant | Code | Standard |
@@ -216,8 +317,10 @@ string escape hatch.
 Two layers of validation run at different times:
 
 1. **Setter-time (`SidcValidationError`)** — thrown immediately for malformed
-   input (wrong number of digits) or unknown enum codes. This catches bugs at
-   the call site rather than deep inside rendering code.
+   input (wrong number of digits) or unknown enum codes. Values must be
+   strings: passing a number or other non-string value throws rather than
+   being coerced. This catches bugs at the call site rather than deep inside
+   rendering code.
 2. **`toString()`-time combination checks** — cross-field rules mirroring
    milsymbol's parser. By default problems are emitted with `console.warn`;
    with `{ strict: true }` they throw `SidcCombinationError`.
@@ -235,7 +338,18 @@ Active combination rules:
 - Raw version/symbol-set codes outside milsymbol's known tables are reported.
 
 ```ts
-import { Sidc, SidcValidationError, SidcCombinationError, Context, StandardIdentity, SymbolSet, Status } from "milsymbol-sidc";
+import {
+  Amplifier,
+  Context,
+  HqTaskForceDummy,
+  Sidc,
+  SidcCombinationError,
+  SidcValidationError,
+  Standard,
+  StandardIdentity,
+  Status,
+  SymbolSet,
+} from "milsymbol-sidc";
 
 // Throws immediately: "9" is not a valid identity code.
 new Sidc().identity("9" as never); // SidcValidationError
@@ -252,6 +366,17 @@ new Sidc({ strict: true })
   .symbolSet(SymbolSet.LandUnit)
   .toString(); // "13161000000000000000", no warnings
 
+// A complete structural 20-position SIDC using raw entity/modifier codes.
+new Sidc({ standard: Standard.App6, strict: true })
+  .identity(StandardIdentity.Friend)
+  .symbolSet(SymbolSet.LandUnit)
+  .hqTaskForceDummy(HqTaskForceDummy.Headquarters)
+  .amplifier(Amplifier.BattalionSquadron)
+  .entity("123456")
+  .modifier1("01")
+  .modifier2("09")
+  .toString(); // "14031002161234560109"
+
 // A real combination problem: condition status on a control measure.
 new Sidc({ strict: true })
   .symbolSet(SymbolSet.ControlMeasure)
@@ -275,6 +400,72 @@ try {
 Error classes: `SidcError` (base) → `SidcValidationError`,
 `SidcCombinationError`.
 
+### Reading and reporting problems
+
+`console.warn` is only the default. Inspect problems without side effects with
+`problems()` and `isValid()`, or route them anywhere with `onWarning`:
+
+```ts
+import { Sidc, SymbolSet, Status } from "milsymbol-sidc";
+
+const sidc = new Sidc()
+  .symbolSet(SymbolSet.ControlMeasure)
+  .status(Status.Destroyed);
+
+sidc.problems();
+// [{ code: "condition-status-control-measure", message: "…" }]
+sidc.isValid(); // false
+
+new Sidc({ onWarning: (problem) => log.warn(problem.code) })
+  .symbolSet(SymbolSet.ControlMeasure)
+  .status(Status.Destroyed)
+  .toString(); // no console output; onWarning is called once
+```
+
+Every problem carries a stable `code` and the exact legacy warning `message`.
+`problems()` never throws, even for builders created with `{ strict: true }`;
+`toString()` still throws `SidcCombinationError` in strict mode.
+
+## Parsing a SIDC
+
+`Sidc.parse()` turns a 20-character numeric SIDC back into a builder so you can
+validate, edit, and re-render existing codes. `Sidc.tryParse()` returns
+`undefined` instead of throwing.
+
+```ts
+import { Sidc } from "milsymbol-sidc";
+
+const sidc = Sidc.parse("14031002161234560109");
+sidc.toObject().entity; // "123456"
+
+sidc.with({ modifier1: "02" }).toString(); // "14031002161234560209"
+Sidc.tryParse("not-a-sidc"); // undefined
+```
+
+Round-tripping is guaranteed: `Sidc.parse(s).toString() === s` for any string
+this library produces. Only the 20-character numeric form is supported today;
+letter-based SIDCs and the 21–30 character extension are not.
+
+## Catalogs (optional)
+
+The `milsymbol-sidc/catalogs` subpath exposes a membership catalog generated from
+milsymbol's numeric symbol data: which entity and modifier codes milsymbol
+registers for each symbol set. It is a separate entry point, so the core builder
+stays data-free unless you import it.
+
+```ts
+import { entityCodes, isKnownEntityCode } from "milsymbol-sidc/catalogs";
+
+isKnownEntityCode("10", "121100"); // true — a registered land-unit entity
+isKnownEntityCode("10", "999999"); // false
+entityCodes("10").length; // number of registered land-unit codes
+```
+
+The catalog is **membership only**: it carries no semantic names and is never
+consulted by `toString()`, so raw entity and modifier values still encode
+without recognition warnings. Regenerate it with `npm run generate:catalogs`;
+the milsymbol version it was derived from is exported as `CATALOG_SOURCE`.
+
 ## Using with milsymbol
 
 milsymbol routes any SIDC whose first two characters are digits to its numeric
@@ -304,11 +495,29 @@ const svg = symbol.asSVG();
 
 ### Node.js (CommonJS)
 
+`milsymbol-sidc` is ESM-only. From CommonJS, load it with dynamic `import()`.
+`milsymbol` itself can be `require`d directly:
+
 ```js
 const ms = require("milsymbol");
-// same API as above
+
+async function render() {
+  const { Sidc, Standard, StandardIdentity, SymbolSet } = await import(
+    "milsymbol-sidc"
+  );
+
+  const sidc = new Sidc({ standard: Standard.App6 })
+    .identity(StandardIdentity.Friend)
+    .symbolSet(SymbolSet.LandUnit)
+    .toString();
+
+  return new ms.Symbol(sidc, { size: 32 }).asSVG();
+}
 ```
 
+Node.js 20.19+ and 22.12+ can also `require("milsymbol-sidc")` directly via
+`require(esm)`; earlier Node 18/20 releases must use `import()`.
+
 ### Browser
 
 ```html
@@ -330,6 +539,18 @@ const ms = require("milsymbol");
 ### Recipes
 
 ```ts
+import {
+  Amplifier,
+  Context,
+  HqTaskForceDummy,
+  Sidc,
+  Standard,
+  StandardIdentity,
+  Status,
+  SymbolSet,
+  Version,
+} from "milsymbol-sidc";
+
 // Hostile planned armored unit
 new Sidc()
   .identity(StandardIdentity.SuspectJoker)
@@ -358,6 +579,15 @@ new Sidc({ standard: Standard.App6, strict: true })
   .symbolSet(SymbolSet.SeaSubsurface)
   .toString(); // "14153500000000000000"
 
+// APP-6 unit with structural entity and modifier fields
+new Sidc({ standard: Standard.App6, strict: true })
+  .identity(StandardIdentity.Friend)
+  .symbolSet(SymbolSet.LandUnit)
+  .entity("123456")
+  .modifier1("01")
+  .modifier2("09")
+  .toString(); // "14031000001234560109"
+
 // APP-6 D configuration retains an explicitly selected compatible edition
 new Sidc({ standard: Standard.App6, strict: true })
   .version(Version.App6D)
@@ -370,20 +600,25 @@ new Sidc({ standard: Standard.App6, strict: true })
 
 ```bash
 npm install
-npm test     # compiles with tsc, then runs node --test against dist/
+npm test                  # compiles with tsc, then runs node --test against dist/
 npm run build
+npm run lint              # eslint
+npm run format:check      # prettier
+npm run generate:catalogs # regenerate src/catalogs.generated.ts from milsymbol
 ```
 
+CI runs the test suite on Node 18/20/22/24, plus lint, formatting, markdownlint,
+coverage, and a check that the generated catalog is current.
+
 Test coverage includes per-field offset encoding for every enum member,
-defaults, immutability, setter validation errors, all combination rules in
-both warn and strict modes, raw-code escape hatches, and error class
-hierarchy.
+defaults, immutability, setter validation errors, extended-field offsets,
+all combination rules in both warn and strict modes, raw-code escape hatches,
+and error class hierarchy.
 
 ## Roadmap
 
-- Positions 8–20: HQ/task force/dummy, echelon/mobility, entity catalog with
-  named icon codes, sector modifiers.
-- Parsing/decoding SIDC strings back into structured fields.
+- Semantic entity and modifier names, layered on the membership catalog.
+- Official positions 21–30 / Set C extension data.
 
 ## License
 

package/dist/src/catalog.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Optional membership catalogs derived from milsymbol's numeric symbol data.
+ *
+ * Import from the `milsymbol-sidc/catalogs` subpath. This module is deliberately
+ * **not** part of the main entry point, so bundlers that only use the builder
+ * never include the catalog data.
+ *
+ * These catalogs answer "which codes does milsymbol register for this symbol
+ * set?". They intentionally carry no semantic names, and they are never
+ * consulted by `Sidc.toString()` - raw entity and modifier values continue to
+ * encode without recognition warnings.
+ *
+ * ```ts
+ * import { isKnownEntityCode } from "milsymbol-sidc/catalogs";
+ *
+ * isKnownEntityCode("10", "121100"); // true for land units
+ * isKnownEntityCode("10", "999999"); // false
+ * ```
+ */
+import { CATALOG_SOURCE } from "./catalogs.generated.js";
+export { CATALOG_SOURCE };
+export type CatalogSource = typeof CATALOG_SOURCE;
+/** Every symbol set the catalog covers, sorted ascending. */
+export declare function catalogSymbolSets(): readonly string[];
+/** `true` when any catalog data exists for the symbol set. */
+export declare function hasCatalog(symbolSet: string): boolean;
+/** Six-digit entity codes milsymbol registers for a symbol set. */
+export declare function entityCodes(symbolSet: string): readonly string[];
+/** `true` when the entity code is registered for the symbol set. */
+export declare function isKnownEntityCode(symbolSet: string, entity: string): boolean;
+/** Two-digit modifier 1 codes milsymbol registers for a symbol set. */
+export declare function modifier1Codes(symbolSet: string): readonly string[];
+/** `true` when modifier 1 is registered for the symbol set. */
+export declare function isKnownModifier1Code(symbolSet: string, modifier: string): boolean;
+/** Two-digit modifier 2 codes milsymbol registers for a symbol set. */
+export declare function modifier2Codes(symbolSet: string): readonly string[];
+/** `true` when modifier 2 is registered for the symbol set. */
+export declare function isKnownModifier2Code(symbolSet: string, modifier: string): boolean;
+//# sourceMappingURL=catalog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EACL,cAAc,EAIf,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC;AAiBlD,6DAA6D;AAC7D,wBAAgB,iBAAiB,IAAI,SAAS,MAAM,EAAE,CAErD;AAED,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,mEAAmE;AACnE,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAEhE;AAED,oEAAoE;AACpE,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAE5E;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAEnE;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAET;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAEnE;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAET"}

package/dist/src/catalog.js

@@ -0,0 +1,63 @@
+/**
+ * Optional membership catalogs derived from milsymbol's numeric symbol data.
+ *
+ * Import from the `milsymbol-sidc/catalogs` subpath. This module is deliberately
+ * **not** part of the main entry point, so bundlers that only use the builder
+ * never include the catalog data.
+ *
+ * These catalogs answer "which codes does milsymbol register for this symbol
+ * set?". They intentionally carry no semantic names, and they are never
+ * consulted by `Sidc.toString()` - raw entity and modifier values continue to
+ * encode without recognition warnings.
+ *
+ * ```ts
+ * import { isKnownEntityCode } from "milsymbol-sidc/catalogs";
+ *
+ * isKnownEntityCode("10", "121100"); // true for land units
+ * isKnownEntityCode("10", "999999"); // false
+ * ```
+ */
+import { CATALOG_SOURCE, ENTITY_CODES, MODIFIER_1_CODES, MODIFIER_2_CODES, } from "./catalogs.generated.js";
+export { CATALOG_SOURCE };
+const EMPTY = Object.freeze([]);
+const SYMBOL_SETS = new Set([
+    ...Object.keys(ENTITY_CODES),
+    ...Object.keys(MODIFIER_1_CODES),
+    ...Object.keys(MODIFIER_2_CODES),
+]);
+function codesFor(table, symbolSet) {
+    return table[symbolSet] ?? EMPTY;
+}
+/** Every symbol set the catalog covers, sorted ascending. */
+export function catalogSymbolSets() {
+    return Object.freeze([...SYMBOL_SETS].sort());
+}
+/** `true` when any catalog data exists for the symbol set. */
+export function hasCatalog(symbolSet) {
+    return SYMBOL_SETS.has(symbolSet);
+}
+/** Six-digit entity codes milsymbol registers for a symbol set. */
+export function entityCodes(symbolSet) {
+    return codesFor(ENTITY_CODES, symbolSet);
+}
+/** `true` when the entity code is registered for the symbol set. */
+export function isKnownEntityCode(symbolSet, entity) {
+    return entityCodes(symbolSet).includes(entity);
+}
+/** Two-digit modifier 1 codes milsymbol registers for a symbol set. */
+export function modifier1Codes(symbolSet) {
+    return codesFor(MODIFIER_1_CODES, symbolSet);
+}
+/** `true` when modifier 1 is registered for the symbol set. */
+export function isKnownModifier1Code(symbolSet, modifier) {
+    return modifier1Codes(symbolSet).includes(modifier);
+}
+/** Two-digit modifier 2 codes milsymbol registers for a symbol set. */
+export function modifier2Codes(symbolSet) {
+    return codesFor(MODIFIER_2_CODES, symbolSet);
+}
+/** `true` when modifier 2 is registered for the symbol set. */
+export function isKnownModifier2Code(symbolSet, modifier) {
+    return modifier2Codes(symbolSet).includes(modifier);
+}
+//# sourceMappingURL=catalog.js.map

package/dist/src/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../src/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EACL,cAAc,EACd,YAAY,EACZ,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,cAAc,EAAE,CAAC;AAG1B,MAAM,KAAK,GAAsB,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAEnD,MAAM,WAAW,GAAwB,IAAI,GAAG,CAAC;IAC/C,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC;IAC5B,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC;IAChC,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC;CACjC,CAAC,CAAC;AAEH,SAAS,QAAQ,CACf,KAAkD,EAClD,SAAiB;IAEjB,OAAO,KAAK,CAAC,SAAS,CAAC,IAAI,KAAK,CAAC;AACnC,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,iBAAiB;IAC/B,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAChD,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,UAAU,CAAC,SAAiB;IAC1C,OAAO,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AACpC,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,WAAW,CAAC,SAAiB;IAC3C,OAAO,QAAQ,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;AAC3C,CAAC;AAED,oEAAoE;AACpE,MAAM,UAAU,iBAAiB,CAAC,SAAiB,EAAE,MAAc;IACjE,OAAO,WAAW,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACjD,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,cAAc,CAAC,SAAiB;IAC9C,OAAO,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;AAC/C,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,oBAAoB,CAClC,SAAiB,EACjB,QAAgB;IAEhB,OAAO,cAAc,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,cAAc,CAAC,SAAiB;IAC9C,OAAO,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAC;AAC/C,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,oBAAoB,CAClC,SAAiB,EACjB,QAAgB;IAEhB,OAAO,cAAc,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;AACtD,CAAC"}

package/dist/src/catalogs.generated.d.ts

@@ -0,0 +1,20 @@
+/**
+ * GENERATED FILE - do not edit by hand.
+ *
+ * Membership catalog derived from milsymbol 3.0.4 (MIT),
+ * Copyright (c) 2017 Måns Beckman - https://www.spatialillusions.com
+ *
+ * Regenerate with `npm run generate:catalogs`.
+ */
+/** Package and version the catalog was generated from. */
+export declare const CATALOG_SOURCE: {
+    readonly name: "milsymbol";
+    readonly version: "3.0.4";
+};
+/** Six-digit entity codes milsymbol registers, keyed by symbol set. */
+export declare const ENTITY_CODES: Readonly<Record<string, readonly string[]>>;
+/** Two-digit modifier 1 codes milsymbol registers, keyed by symbol set. */
+export declare const MODIFIER_1_CODES: Readonly<Record<string, readonly string[]>>;
+/** Two-digit modifier 2 codes milsymbol registers, keyed by symbol set. */
+export declare const MODIFIER_2_CODES: Readonly<Record<string, readonly string[]>>;
+//# sourceMappingURL=catalogs.generated.d.ts.map

package/dist/src/catalogs.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalogs.generated.d.ts","sourceRoot":"","sources":["../../src/catalogs.generated.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,0DAA0D;AAC1D,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,uEAAuE;AACvE,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA0sCjE,CAAC;AAEL,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA0uBrE,CAAC;AAEL,2EAA2E;AAC3E,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA4PrE,CAAC"}