@fgv/ts-bcp47 0.5.1 → 0.5.3

package/bcp47/validation/validateTag.js

@@ -0,0 +1,159 @@
+"use strict";
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidateTag = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const common_1 = require("./common");
+const isCanonical_1 = require("./isCanonical");
+const isInPreferredForm_1 = require("./isInPreferredForm");
+const isStrictlyValid_1 = require("./isStrictlyValid");
+const isValid_1 = require("./isValid");
+const isWellFormed_1 = require("./isWellFormed");
+/**
+ * Validation helpers for BCP-47 language tags.
+ * @public
+ */
+class ValidateTag {
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are in canonical form,
+     * meaning that they are at least well-formed as specified by
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646}, and
+     * all subtags are also
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | capitalized as recommended}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a language tag in canonical, false otherwise.
+     * @example `en-US` is in canonical form, `en-us` is not.
+     * @example `eng-US` is in canonical form, `eng-us` is not.
+     */
+    static isCanonical(subtags) {
+        if (!this._isCanonical) {
+            this._isCanonical = new isCanonical_1.IsCanonicalValidator();
+        }
+        return this._isCanonical.validateSubtags(subtags).isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * in preferred form. Preferred form is valid as specified by
+     * {@link  https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646} and
+     * also meets additional preferences specified in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry} -
+     * extraneous (suppressed) script tags, deprecated language, extlang, script or region tags or
+     * deprecated grandfathered or redundant tags (with a defined preferred-value) are not allowed.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag in preferred form, false otherwise.
+     * @example `en-US` is in preferred form, `en-Latn-US` is not.
+     * @example `cmn` is in preferred form, `zh-cmn-Hans` is not.
+     */
+    static isInPreferredForm(subtags) {
+        if (!this._isInPreferredForm) {
+            this._isInPreferredForm = new isInPreferredForm_1.IsInPreferredFromValidator();
+        }
+        return this._isInPreferredForm.validateSubtags(subtags).isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * strictly valid.  A strictly valid tag is both
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | valid as defined in the RFC}
+     * and meets any other requirements such as
+     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | prefix validity}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a strictly valid language tag, false otherwise.
+     * @example `ca-valencia` is strictly valid, `es-valencia` is not.
+     */
+    static isStrictlyValid(subtags) {
+        return this.validateSubtags(subtags, 'strictly-valid').isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * valid as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags, or the tag itself for grandfathered tags, are defined in the
+     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA language subtag registry}.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a valid language tag, false otherwise.
+     * @example `en-US` is valid, `eng-US` is not.
+     */
+    static isValid(subtags) {
+        return this.validateSubtags(subtags, 'valid').isSuccess();
+    }
+    /**
+     * Determines if supplied {@link Bcp47.Subtags | subtags } are
+     * well-formed as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},
+     * meaning that all subtags meet the grammar defined in the specification.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.
+     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent
+     * a well-formed language tag, false otherwise.
+     * @example `en-US` is valid, `english-US` is not.
+     * @public
+     */
+    static isWellFormed(subtags) {
+        return this.validateSubtags(subtags, 'well-formed').isSuccess();
+    }
+    /**
+     * Chooses an appropriate default tag validator given desired and optional current
+     * {@link Bcp47.TagValidity | validation level}.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns An appropriate {@link Bcp47.TagValidator | tag validator} or `undefined` if no
+     * additional validation is necessary.
+     * @internal
+     */
+    static chooseValidator(wantValidity, haveValidity) {
+        if (haveValidity && (0, common_1.compareValidity)(haveValidity, wantValidity) >= 0) {
+            return undefined;
+        }
+        if (!this._validators) {
+            this._validators = {
+                /* eslint-disable @typescript-eslint/naming-convention */
+                unknown: new isWellFormed_1.IsWellFormedValidator(),
+                'well-formed': new isWellFormed_1.IsWellFormedValidator(),
+                valid: new isValid_1.IsValidValidator(),
+                'strictly-valid': new isStrictlyValid_1.IsStrictlyValidValidator(),
+                /* eslint-enable @typescript-eslint/naming-convention */
+            };
+        }
+        return this._validators[wantValidity];
+    }
+    /**
+     * Validates supplied {@link Bcp47.Subtags | subtags } to a requested
+     * {@link Bcp47.TagValidity | validity level}, if necessary.
+     * @param subtags - The {@link Bcp47.Subtags | subtags } to be validated.
+     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.
+     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.
+     * @returns `Success` with the validated {@link Bcp47.Subtags | subtags }, or
+     * `Failure` with details if an error occurs.
+     * @public
+     */
+    static validateSubtags(subtags, wantValidity, haveValidity) {
+        var _a;
+        const validator = this.chooseValidator(wantValidity, haveValidity);
+        // istanbul ignore next - a pain to test
+        return (_a = validator === null || validator === void 0 ? void 0 : validator.validateSubtags(subtags)) !== null && _a !== void 0 ? _a : (0, ts_utils_1.succeed)(true);
+    }
+}
+exports.ValidateTag = ValidateTag;
+ValidateTag._validators = undefined;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validateTag.js","sourceRoot":"","sources":["../../../src/bcp47/validation/validateTag.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAgD;AAChD,qCAAwD;AAExD,+CAAqD;AACrD,2DAAiE;AACjE,uDAA6D;AAC7D,uCAA6C;AAC7C,iDAAuD;AAIvD;;;GAGG;AACH,MAAa,WAAW;IAKpB;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,WAAW,CAAC,OAAgB;QACtC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;YACpB,IAAI,CAAC,YAAY,GAAG,IAAI,kCAAoB,EAAE,CAAC;SAClD;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,iBAAiB,CAAC,OAAgB;QAC5C,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE;YAC1B,IAAI,CAAC,kBAAkB,GAAG,IAAI,8CAA0B,EAAE,CAAC;SAC9D;QACD,OAAO,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;IACxE,CAAC;IAED;;;;;;;;;;OAUG;IACI,MAAM,CAAC,eAAe,CAAC,OAAgB;QAC1C,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC,SAAS,EAAE,CAAC;IACvE,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,OAAO,CAAC,OAAgB;QAClC,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC;IAC9D,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,YAAY,CAAC,OAAgB;QACvC,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,SAAS,EAAE,CAAC;IACpE,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,eAAe,CAAC,YAAyB,EAAE,YAA0B;QAC/E,IAAI,YAAY,IAAI,IAAA,wBAAe,EAAC,YAAY,EAAE,YAAY,CAAC,IAAI,CAAC,EAAE;YAClE,OAAO,SAAS,CAAC;SACpB;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACnB,IAAI,CAAC,WAAW,GAAG;gBACf,yDAAyD;gBACzD,OAAO,EAAE,IAAI,oCAAqB,EAAE;gBACpC,aAAa,EAAE,IAAI,oCAAqB,EAAE;gBAC1C,KAAK,EAAE,IAAI,0BAAgB,EAAE;gBAC7B,gBAAgB,EAAE,IAAI,0CAAwB,EAAE;gBAChD,wDAAwD;aAC3D,CAAC;SACL;QACD,OAAO,IAAI,CAAC,WAAY,CAAC,YAAY,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;OASG;IACI,MAAM,CAAC,eAAe,CAAC,OAAgB,EAAE,YAAyB,EAAE,YAA0B;;QACjG,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QACnE,wCAAwC;QACxC,OAAO,MAAA,SAAS,aAAT,SAAS,uBAAT,SAAS,CAAE,eAAe,CAAC,OAAO,CAAC,mCAAI,IAAA,kBAAO,EAAC,IAAI,CAAC,CAAC;IAChE,CAAC;;AAjIL,kCAkIC;AA/HkB,uBAAW,GAAkD,SAAS,CAAC","sourcesContent":["/*\n * Copyright (c) 2022 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, succeed } from '@fgv/ts-utils';\nimport { TagValidity, compareValidity } from './common';\n\nimport { IsCanonicalValidator } from './isCanonical';\nimport { IsInPreferredFromValidator } from './isInPreferredForm';\nimport { IsStrictlyValidValidator } from './isStrictlyValid';\nimport { IsValidValidator } from './isValid';\nimport { IsWellFormedValidator } from './isWellFormed';\nimport { Subtags } from '../common';\nimport { TagValidator } from './baseValidator';\n\n/**\n * Validation helpers for BCP-47 language tags.\n * @public\n */\nexport class ValidateTag {\n    private static _isCanonical?: TagValidator;\n    private static _isInPreferredForm?: TagValidator;\n    private static _validators: Record<TagValidity, TagValidator> | undefined = undefined;\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are in canonical form,\n     * meaning that they are at least well-formed as specified by\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646}, and\n     * all subtags are also\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.1.1 | capitalized as recommended}.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a language tag in canonical, false otherwise.\n     * @example `en-US` is in canonical form, `en-us` is not.\n     * @example `eng-US` is in canonical form, `eng-us` is not.\n     */\n    public static isCanonical(subtags: Subtags): boolean {\n        if (!this._isCanonical) {\n            this._isCanonical = new IsCanonicalValidator();\n        }\n        return this._isCanonical.validateSubtags(subtags).isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * in preferred form. Preferred form is valid as specified by\n     * {@link  https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646} and\n     * also meets additional preferences specified in the\n     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | language subtag registry} -\n     * extraneous (suppressed) script tags, deprecated language, extlang, script or region tags or\n     * deprecated grandfathered or redundant tags (with a defined preferred-value) are not allowed.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a valid language tag in preferred form, false otherwise.\n     * @example `en-US` is in preferred form, `en-Latn-US` is not.\n     * @example `cmn` is in preferred form, `zh-cmn-Hans` is not.\n     */\n    public static isInPreferredForm(subtags: Subtags): boolean {\n        if (!this._isInPreferredForm) {\n            this._isInPreferredForm = new IsInPreferredFromValidator();\n        }\n        return this._isInPreferredForm.validateSubtags(subtags).isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * strictly valid.  A strictly valid tag is both\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | valid as defined in the RFC}\n     * and meets any other requirements such as\n     * {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-3.1.8 | prefix validity}.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a strictly valid language tag, false otherwise.\n     * @example `ca-valencia` is strictly valid, `es-valencia` is not.\n     */\n    public static isStrictlyValid(subtags: Subtags): boolean {\n        return this.validateSubtags(subtags, 'strictly-valid').isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * valid as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},\n     * meaning that all subtags, or the tag itself for grandfathered tags, are defined in the\n     * {@link https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry | IANA language subtag registry}.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a valid language tag, false otherwise.\n     * @example `en-US` is valid, `eng-US` is not.\n     */\n    public static isValid(subtags: Subtags): boolean {\n        return this.validateSubtags(subtags, 'valid').isSuccess();\n    }\n\n    /**\n     * Determines if supplied {@link Bcp47.Subtags | subtags } are\n     * well-formed as specified by {@link https://www.rfc-editor.org/rfc/rfc5646.html#section-2.2.9 | RFC 5646},\n     * meaning that all subtags meet the grammar defined in the specification.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to test.\n     * @returns `true` if the {@link Bcp47.Subtags | subtags } represent\n     * a well-formed language tag, false otherwise.\n     * @example `en-US` is valid, `english-US` is not.\n     * @public\n     */\n    public static isWellFormed(subtags: Subtags): boolean {\n        return this.validateSubtags(subtags, 'well-formed').isSuccess();\n    }\n\n    /**\n     * Chooses an appropriate default tag validator given desired and optional current\n     * {@link Bcp47.TagValidity | validation level}.\n     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.\n     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.\n     * @returns An appropriate {@link Bcp47.TagValidator | tag validator} or `undefined` if no\n     * additional validation is necessary.\n     * @internal\n     */\n    public static chooseValidator(wantValidity: TagValidity, haveValidity?: TagValidity): TagValidator | undefined {\n        if (haveValidity && compareValidity(haveValidity, wantValidity) >= 0) {\n            return undefined;\n        }\n\n        if (!this._validators) {\n            this._validators = {\n                /* eslint-disable @typescript-eslint/naming-convention */\n                unknown: new IsWellFormedValidator(),\n                'well-formed': new IsWellFormedValidator(),\n                valid: new IsValidValidator(),\n                'strictly-valid': new IsStrictlyValidValidator(),\n                /* eslint-enable @typescript-eslint/naming-convention */\n            };\n        }\n        return this._validators![wantValidity];\n    }\n\n    /**\n     * Validates supplied {@link Bcp47.Subtags | subtags } to a requested\n     * {@link Bcp47.TagValidity | validity level}, if necessary.\n     * @param subtags - The {@link Bcp47.Subtags | subtags } to be validated.\n     * @param wantValidity - The desired {@link Bcp47.TagValidity | validity level}.\n     * @param haveValidity - (optional) The current {@link Bcp47.TagValidity | validity level}.\n     * @returns `Success` with the validated {@link Bcp47.Subtags | subtags }, or\n     * `Failure` with details if an error occurs.\n     * @public\n     */\n    public static validateSubtags(subtags: Subtags, wantValidity: TagValidity, haveValidity?: TagValidity): Result<boolean> {\n        const validator = this.chooseValidator(wantValidity, haveValidity);\n        // istanbul ignore next - a pain to test\n        return validator?.validateSubtags(subtags) ?? succeed(true);\n    }\n}\n"]}

package/iana/common/converters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../../../src/iana/common/converters.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,SAAS,EAAc,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC;;;GAGG;AACH,eAAO,MAAM,gBAAgB,wDAAuC,CAAC;AAErE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,2DAAyC,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,mBAAmB,2DAAyC,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,eAAe,uDAAqC,CAAC;AAElE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,EAAE,cAAc,EAAE,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAKhH"}

package/iana/common/converters.js

@@ -0,0 +1,84 @@
+"use strict";
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datedRegistry = exports.unM49RegionCode = exports.isoAlpha3RegionCode = exports.isoAlpha2RegionCode = exports.yearMonthDaySpec = void 0;
+const Validate = __importStar(require("./validate"));
+const ts_utils_1 = require("@fgv/ts-utils");
+/**
+ * Validating converter from string {@link Iana.Model.YearMonthDaySpec}.
+ * @public
+ */
+exports.yearMonthDaySpec = Validate.yearMonthDateSpec.converter;
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha2RegionCode}.
+ * @public
+ */
+exports.isoAlpha2RegionCode = Validate.isoAlpha2RegionCode.converter;
+/**
+ * Validating converter from string {@link Iana.Model.IsoAlpha3RegionCode}.
+ * @public
+ */
+exports.isoAlpha3RegionCode = Validate.isoAlpha3RegionCode.converter;
+/**
+ * Validating converter from string {@link Iana.Model.UnM49RegionCode}.
+ * @public
+ */
+exports.unM49RegionCode = Validate.unM49RegionCode.converter;
+/**
+ * Helper function which creates a converter that returns a validated {@Link Iana.Model.DatedRegistry | DatedRegistry}
+ * containing entries of supplied template type `T`.
+ * @param entryConverter - A `Converter<T>` to validate each entry
+ * @returns A new validating `Converter` which yields {@Link Iana.Model.DatedRegistry | DatedRegistry<T>}
+ * @public
+ */
+function datedRegistry(entryConverter) {
+    return ts_utils_1.Converters.strictObject({
+        fileDate: exports.yearMonthDaySpec,
+        entries: ts_utils_1.Converters.arrayOf(entryConverter),
+    });
+}
+exports.datedRegistry = datedRegistry;
+//# sourceMappingURL=data:application/json;base64,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

package/iana/common/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/iana/common/model.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEtC;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;AAEvE;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,KAAK,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;AAEvE;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAE/D;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;AAEjE;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,OAAO,EAAE,CAAC,EAAE,CAAC;CAChB"}

package/{src/unsd/csv → iana/common}/model.js

@@ -21,4 +21,4 @@
  * SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/iana/common/registeredItems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registeredItems.d.ts","sourceRoot":"","sources":["../../../src/iana/common/registeredItems.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD;;GAEG;AACH,8BAAsB,mBAAmB,CAAC,KAAK,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,EAAE,KAAK;IACtF,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC5C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAChC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAEtD,SAAS,aAAa,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB,CAAC,IAAI,CAAC;IAM7D,UAAU,IAAI,IAAI,EAAE;IAIpB,MAAM,IAAI,KAAK,EAAE;IAIjB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS;IAcnD,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS;IAI5D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC;IAK5C,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC,KAAK,GAAG,SAAS,CAAC;IAKjE,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,IAAI;IAIvC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,IAAI;IAItC,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;IAIvC,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;IAS5C,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,IAAI;IAQlC,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,IAAI;IAO3C,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;IAI9C,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;IAUzC,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC;IAUpD,SAAS,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;aAO/B,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;IAC/C,SAAS,CAAC,QAAQ,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC;CAChE"}

package/iana/common/registeredItems.js

@@ -0,0 +1,124 @@
+"use strict";
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegisteredItemScope = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+/**
+ * @internal
+ */
+class RegisteredItemScope {
+    constructor(type, validate) {
+        this._items = new Map();
+        this._type = type;
+        this._validate = validate;
+    }
+    getAllKeys() {
+        return Array.from(this._items.keys());
+    }
+    getAll() {
+        return Array.from(this._items.values());
+    }
+    tryGet(want) {
+        if (want) {
+            const got = this._items.get(want);
+            if (!got) {
+                const result = this.toCanonical(want);
+                if (result.isSuccess()) {
+                    return this._items.get(result.value);
+                }
+            }
+            return got;
+        }
+        return undefined;
+    }
+    tryGetCanonical(want) {
+        return want ? this._items.get(want) : undefined;
+    }
+    get(want) {
+        const got = this.tryGet(want);
+        return got ? (0, ts_utils_1.succeed)(got) : (0, ts_utils_1.fail)(`invalid ${this._type}`);
+    }
+    getCanonical(want) {
+        const got = this.tryGetCanonical(want);
+        return got ? (0, ts_utils_1.succeed)(got) : (0, ts_utils_1.fail)(`invalid ${this._type}`);
+    }
+    isWellFormed(val) {
+        return this._validate.isWellFormed(val);
+    }
+    isCanonical(val) {
+        return this._validate.isCanonical(val);
+    }
+    toCanonical(val) {
+        return this._validate.toCanonical(val);
+    }
+    toValidCanonical(val) {
+        return this._validate.toCanonical(val).onSuccess((canonical) => {
+            if (this._items.has(canonical)) {
+                return (0, ts_utils_1.succeed)(canonical);
+            }
+            return (0, ts_utils_1.fail)(`${val}: invalid ${this._type}`);
+        });
+    }
+    isValid(val) {
+        const result = this.toCanonical(val);
+        if (result.isSuccess()) {
+            return this._items.has(result.value);
+        }
+        return false;
+    }
+    isValidCanonical(val) {
+        if (this.isCanonical(val)) {
+            return this._items.has(val);
+        }
+        return false;
+    }
+    verifyIsWellFormed(val) {
+        return this._validate.verifyIsWellFormed(val);
+    }
+    verifyIsValid(val) {
+        if (this.isValid(val)) {
+            return (0, ts_utils_1.succeed)(val);
+        }
+        if (!this.isWellFormed(val)) {
+            return (0, ts_utils_1.fail)(`${val}: malformed ${this._type}.`);
+        }
+        return (0, ts_utils_1.fail)(`${val}: invalid ${this._type}.`);
+    }
+    verifyIsCanonical(val) {
+        if (this.isCanonical(val)) {
+            return (0, ts_utils_1.succeed)(val);
+        }
+        if (!this.isWellFormed(val)) {
+            return (0, ts_utils_1.fail)(`${val}: malformed ${this._type}`);
+        }
+        return (0, ts_utils_1.fail)(`${val}: non-canonical ${this._type}`);
+    }
+    _validateKey(key) {
+        if (!this.isCanonical(key)) {
+            return (0, ts_utils_1.fail)(`${key}: ${this._type} is not in canonical form`);
+        }
+        return (0, ts_utils_1.succeed)(true);
+    }
+}
+exports.RegisteredItemScope = RegisteredItemScope;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"registeredItems.js","sourceRoot":"","sources":["../../../src/iana/common/registeredItems.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2022 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, fail, succeed } from '@fgv/ts-utils';\nimport { ValidationHelpers } from '../../utils';\n\n/**\n * @internal\n */\nexport abstract class RegisteredItemScope<TTYPE extends string, TKEY extends string, TITEM> {\n    protected readonly _items: Map<TKEY, TITEM>;\n    protected readonly _type: TTYPE;\n    protected readonly _validate: ValidationHelpers<TKEY>;\n\n    protected constructor(type: TTYPE, validate: ValidationHelpers<TKEY>) {\n        this._items = new Map();\n        this._type = type;\n        this._validate = validate;\n    }\n\n    public getAllKeys(): TKEY[] {\n        return Array.from(this._items.keys());\n    }\n\n    public getAll(): TITEM[] {\n        return Array.from(this._items.values());\n    }\n\n    public tryGet(want: string | undefined): TITEM | undefined {\n        if (want) {\n            const got = this._items.get(want as TKEY);\n            if (!got) {\n                const result = this.toCanonical(want);\n                if (result.isSuccess()) {\n                    return this._items.get(result.value as TKEY);\n                }\n            }\n            return got;\n        }\n        return undefined;\n    }\n\n    public tryGetCanonical(want: string | undefined): TITEM | undefined {\n        return want ? this._items.get(want as TKEY) : undefined;\n    }\n\n    public get(want: string | undefined): Result<TITEM> {\n        const got = this.tryGet(want);\n        return got ? succeed(got) : fail(`invalid ${this._type}`);\n    }\n\n    public getCanonical(want: string | undefined): Result<TITEM | undefined> {\n        const got = this.tryGetCanonical(want);\n        return got ? succeed(got) : fail(`invalid ${this._type}`);\n    }\n\n    public isWellFormed(val: unknown): val is TKEY {\n        return this._validate.isWellFormed(val);\n    }\n\n    public isCanonical(val: unknown): val is TKEY {\n        return this._validate.isCanonical(val);\n    }\n\n    public toCanonical(val: unknown): Result<TKEY> {\n        return this._validate.toCanonical(val);\n    }\n\n    public toValidCanonical(val: unknown): Result<TKEY> {\n        return this._validate.toCanonical(val).onSuccess((canonical) => {\n            if (this._items.has(canonical)) {\n                return succeed(canonical);\n            }\n            return fail(`${val}: invalid ${this._type}`);\n        });\n    }\n\n    public isValid(val: unknown): val is TKEY {\n        const result = this.toCanonical(val);\n        if (result.isSuccess()) {\n            return this._items.has(result.value);\n        }\n        return false;\n    }\n\n    public isValidCanonical(val: unknown): val is TKEY {\n        if (this.isCanonical(val)) {\n            return this._items.has(val);\n        }\n        return false;\n    }\n\n    public verifyIsWellFormed(val: unknown): Result<TKEY> {\n        return this._validate.verifyIsWellFormed(val);\n    }\n\n    public verifyIsValid(val: unknown): Result<TKEY> {\n        if (this.isValid(val)) {\n            return succeed(val);\n        }\n        if (!this.isWellFormed(val)) {\n            return fail(`${val}: malformed ${this._type}.`);\n        }\n        return fail(`${val}: invalid ${this._type}.`);\n    }\n\n    public verifyIsCanonical(val: unknown): Result<TKEY> {\n        if (this.isCanonical(val)) {\n            return succeed(val);\n        }\n        if (!this.isWellFormed(val)) {\n            return fail(`${val}: malformed ${this._type}`);\n        }\n        return fail(`${val}: non-canonical ${this._type}`);\n    }\n\n    protected _validateKey(key: TKEY): Result<true> {\n        if (!this.isCanonical(key)) {\n            return fail(`${key}: ${this._type} is not in canonical form`);\n        }\n        return succeed(true);\n    }\n\n    public abstract add(entry: TITEM): Result<true>;\n    protected abstract _validateEntry(entry: TITEM): Result<true>;\n}\n"]}

package/iana/common/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/iana/common/utils.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE3C;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,gBAAgB,CAEpD"}

package/iana/common/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nowAsYearMonthDay = void 0;
+const luxon_1 = require("luxon");
+/**
+ * Gets the current date as an {@link Iana.YearMonthDaySpec}.
+ * @public
+ */
+function nowAsYearMonthDay() {
+    return luxon_1.DateTime.now().toFormat('yyyy-LL-dd');
+}
+exports.nowAsYearMonthDay = nowAsYearMonthDay;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaWFuYS9jb21tb24vdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW9CRzs7O0FBRUgsaUNBQWlDO0FBR2pDOzs7R0FHRztBQUNILFNBQWdCLGlCQUFpQjtJQUM3QixPQUFPLGdCQUFRLENBQUMsR0FBRyxFQUFFLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FBcUIsQ0FBQztBQUNyRSxDQUFDO0FBRkQsOENBRUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDIxIEVyaWsgRm9ydHVuZVxuICpcbiAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHlcbiAqIG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlIFwiU29mdHdhcmVcIiksIHRvIGRlYWxcbiAqIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHNcbiAqIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGxcbiAqIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpc1xuICogZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczpcbiAqXG4gKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGxcbiAqIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuXG4gKlxuICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEIFwiQVMgSVNcIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUlxuICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksXG4gKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEVcbiAqIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVJcbiAqIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sXG4gKiBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTIElOIFRIRVxuICogU09GVFdBUkUuXG4gKi9cblxuaW1wb3J0IHsgRGF0ZVRpbWUgfSBmcm9tICdsdXhvbic7XG5pbXBvcnQgeyBZZWFyTW9udGhEYXlTcGVjIH0gZnJvbSAnLi9tb2RlbCc7XG5cbi8qKlxuICogR2V0cyB0aGUgY3VycmVudCBkYXRlIGFzIGFuIHtAbGluayBJYW5hLlllYXJNb250aERheVNwZWN9LlxuICogQHB1YmxpY1xuICovXG5leHBvcnQgZnVuY3Rpb24gbm93QXNZZWFyTW9udGhEYXkoKTogWWVhck1vbnRoRGF5U3BlYyB7XG4gICAgcmV0dXJuIERhdGVUaW1lLm5vdygpLnRvRm9ybWF0KCd5eXl5LUxMLWRkJykgYXMgWWVhck1vbnRoRGF5U3BlYztcbn1cbiJdfQ==

package/iana/common/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/iana/common/validate.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAGtD;;GAEG;AACH,eAAO,MAAM,iBAAiB,0DAI5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB,6DAK9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB,6DAK9B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe,yDAI1B,CAAC"}

package/iana/common/validate.js

@@ -0,0 +1,61 @@
+"use strict";
+/*
+ * Copyright (c) 2021 Erik Fortune
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unM49RegionCode = exports.isoAlpha3RegionCode = exports.isoAlpha2RegionCode = exports.yearMonthDateSpec = void 0;
+const utils_1 = require("../../utils");
+const ts_utils_1 = require("@fgv/ts-utils");
+/**
+ * @public
+ */
+exports.yearMonthDateSpec = new utils_1.RegExpValidationHelpers({
+    description: 'Year-Month-Date value',
+    wellFormed: /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/,
+    canonical: /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/,
+});
+/**
+ * @public
+ */
+exports.isoAlpha2RegionCode = new utils_1.RegExpValidationHelpers({
+    description: 'ISO 3166-2 Alpha-2 region code',
+    wellFormed: /^[A-Za-z]{2}$/,
+    canonical: /^[A-Z]{2}$/,
+    toCanonical: (from) => (0, ts_utils_1.succeed)(from.toUpperCase()),
+});
+/**
+ * @public
+ */
+exports.isoAlpha3RegionCode = new utils_1.RegExpValidationHelpers({
+    description: 'ISO 3166-2 Alpha-3 region code',
+    wellFormed: /^[A-Za-z]{3}$/,
+    canonical: /^[A-Z]{3}$/,
+    toCanonical: (from) => (0, ts_utils_1.succeed)(from.toUpperCase()),
+});
+/**
+ * @public
+ */
+exports.unM49RegionCode = new utils_1.RegExpValidationHelpers({
+    description: 'UN M.49 3-digit region code',
+    wellFormed: /^[0-9]{3}$/,
+    canonical: /^[0-9]{3}$/,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/iana/converters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converters.d.ts","sourceRoot":"","sources":["../../src/iana/converters.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAE3C,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,GAAG,EAAE,CAAC"}

package/{src/iana/jar/model.js → iana/converters.js}

@@ -36,9 +36,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -46,9 +43,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LanguageSubtags = void 0;
-__exportStar(require("./jarModel"), exports);
-const LanguageSubtags = __importStar(require("./language-subtags/model"));
-exports.LanguageSubtags = LanguageSubtags;
-//# sourceMappingURL=data:application/json;base64,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
+exports.Jar = void 0;
+const Jar = __importStar(require("./jar/jarConverters"));
+exports.Jar = Jar;
+__exportStar(require("./common/converters"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udmVydGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pYW5hL2NvbnZlcnRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW9CRzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFSCx5REFBMkM7QUFHbEMsa0JBQUc7QUFEWixzREFBb0MiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDIyIEVyaWsgRm9ydHVuZVxuICpcbiAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHlcbiAqIG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlIFwiU29mdHdhcmVcIiksIHRvIGRlYWxcbiAqIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSByaWdodHNcbiAqIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5zZSwgYW5kL29yIHNlbGxcbiAqIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpc1xuICogZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczpcbiAqXG4gKiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGxcbiAqIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdhcmUuXG4gKlxuICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEIFwiQVMgSVNcIiwgV0lUSE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUlxuICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksXG4gKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTCBUSEVcbiAqIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVJcbiAqIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sXG4gKiBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJTkdTIElOIFRIRVxuICogU09GVFdBUkUuXG4gKi9cblxuaW1wb3J0ICogYXMgSmFyIGZyb20gJy4vamFyL2phckNvbnZlcnRlcnMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi9jb252ZXJ0ZXJzJztcbmV4cG9ydCB7IEphciB9O1xuIl19