@aidc-toolkit/app-extension 1.0.23-beta → 1.0.25-beta

package/dist/gs1/identifier-proxy.js

@@ -1,782 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { CPID_VALIDATOR, GCN_VALIDATOR, GDTI_VALIDATOR, GIAI_VALIDATOR, GINC_VALIDATOR, GLN_VALIDATOR, GMN_VALIDATOR, GRAI_VALIDATOR, GSIN_VALIDATOR, GSRN_VALIDATOR, GTIN12_VALIDATOR, GTIN13_VALIDATOR, GTIN8_VALIDATOR, GTINCreator, GTINValidator, PrefixManager, PrefixTypes, PrefixValidator, SSCC_VALIDATOR } from "@aidc-toolkit/gs1";
-import { Sequence } from "@aidc-toolkit/utility";
-import { expandParameterDescriptor, ProxyClass, ProxyMethod, ProxyParameter, Types } from "../descriptor.js";
-import { LibProxy } from "../lib-proxy.js";
-import { i18nextAppExtension } from "../locale/i18n.js";
-import { isNullish } from "../types.js";
-import { exclusionAllNumericParameterDescriptor } from "../utility/character-set-descriptor.js";
-import { StringProxy } from "../utility/string-proxy.js";
-import { countParameterDescriptor, startValueParameterDescriptor, valueParameterDescriptor } from "../utility/transformer-descriptor.js";
-const identifierParameterDescriptor = {
-    name: "identifier",
-    type: Types.String,
-    isMatrix: true,
-    isRequired: true
-};
-const validateIdentifierParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    sortOrder: 0,
-    name: "validateIdentifier"
-};
-class IdentifierValidatorProxy extends StringProxy {
-    _validator;
-    constructor(appExtension, validator) {
-        super(appExtension);
-        this._validator = validator;
-    }
-    get validator() {
-        return this._validator;
-    }
-}
-class NumericIdentifierValidatorProxy extends IdentifierValidatorProxy {
-    validate(matrixIdentifiers) {
-        return this.validateString(this.validator, matrixIdentifiers);
-    }
-}
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(validateIdentifierParameterDescriptor))
-], NumericIdentifierValidatorProxy.prototype, "validate", null);
-class GTINValidatorProxy extends NumericIdentifierValidatorProxy {
-}
-class NonGTINNumericIdentifierValidatorProxy extends NumericIdentifierValidatorProxy {
-}
-class SerializableNumericIdentifierValidatorProxy extends NonGTINNumericIdentifierValidatorProxy {
-}
-class NonNumericIdentifierValidatorProxy extends IdentifierValidatorProxy {
-    validate(matrixIdentifiers, exclusion) {
-        return this.validateString(this.validator, matrixIdentifiers, {
-            exclusion: exclusion ?? undefined
-        });
-    }
-}
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(validateIdentifierParameterDescriptor)),
-    __param(1, ProxyParameter(exclusionAllNumericParameterDescriptor))
-], NonNumericIdentifierValidatorProxy.prototype, "validate", null);
-let GTIN13ValidatorProxy = class GTIN13ValidatorProxy extends GTINValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GTIN13_VALIDATOR);
-    }
-};
-GTIN13ValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GTIN13"
-    })
-], GTIN13ValidatorProxy);
-export { GTIN13ValidatorProxy };
-let GTIN12ValidatorProxy = class GTIN12ValidatorProxy extends GTINValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GTIN12_VALIDATOR);
-    }
-};
-GTIN12ValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GTIN12"
-    })
-], GTIN12ValidatorProxy);
-export { GTIN12ValidatorProxy };
-let GTIN8ValidatorProxy = class GTIN8ValidatorProxy extends GTINValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GTIN8_VALIDATOR);
-    }
-};
-GTIN8ValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GTIN8"
-    })
-], GTIN8ValidatorProxy);
-export { GTIN8ValidatorProxy };
-const zeroSuppressibleGTIN12ParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    name: "zeroSuppressibleGTIN12"
-};
-const zeroSuppressedGTIN12ParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    name: "zeroSuppressedGTIN12"
-};
-const indicatorDigitParameterDescriptor = {
-    name: "indicatorDigit",
-    type: Types.String,
-    isMatrix: false,
-    isRequired: true
-};
-const convertGTINParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    name: "convertGTIN"
-};
-const normalizeGTINParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    name: "normalizeGTIN"
-};
-const validateGTINParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    name: "validateGTIN"
-};
-const gtinLevelParameterDescriptor = {
-    name: "gtinLevel",
-    type: Types.Number,
-    isMatrix: false,
-    isRequired: false
-};
-const validateGTIN14ParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    name: "validateGTIN14"
-};
-const rcnFormatParameterDescriptor = {
-    name: "rcnFormat",
-    type: Types.String,
-    isMatrix: false,
-    isRequired: true
-};
-const rcnParameterDescriptor = {
-    name: "rcn",
-    type: Types.String,
-    isMatrix: true,
-    isRequired: true
-};
-const rcnItemReferenceParameterDescriptor = {
-    name: "rcnItemReference",
-    type: Types.Number,
-    isMatrix: false,
-    isRequired: true
-};
-const rcnPriceOrWeightParameterDescriptor = {
-    name: "rcnPriceOrWeight",
-    type: Types.Number,
-    isMatrix: true,
-    isRequired: true
-};
-let GTINValidatorStaticProxy = class GTINValidatorStaticProxy extends LibProxy {
-    zeroSuppressGTIN12(matrixGTIN12s) {
-        return this.mapMatrix(matrixGTIN12s, gtin12 => GTINValidator.zeroSuppress(gtin12));
-    }
-    zeroExpandGTIN12(matrixZeroSuppressedGTIN12s) {
-        return this.mapMatrix(matrixZeroSuppressedGTIN12s, zeroSuppressedGTIN12 => GTINValidator.zeroExpand(zeroSuppressedGTIN12));
-    }
-    convertToGTIN14(indicatorDigit, matrixGTINs) {
-        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.convertToGTIN14(indicatorDigit, gtin));
-    }
-    normalizeGTIN(matrixGTINs) {
-        return this.mapMatrix(matrixGTINs, gtin => GTINValidator.normalize(gtin));
-    }
-    validateGTIN(matrixGTINs, gtinLevel) {
-        const gtinLevelOrUndefined = gtinLevel ?? undefined;
-        return LibProxy.mapMatrixRangeError(matrixGTINs, (gtin) => {
-            GTINValidator.validateAny(gtin, gtinLevelOrUndefined);
-        });
-    }
-    validateGTIN14(matrixGTIN14s) {
-        return LibProxy.mapMatrixRangeError(matrixGTIN14s, (gtin14) => {
-            GTINValidator.validateGTIN14(gtin14);
-        });
-    }
-    parseVariableMeasureRCN(format, matrixRCNs) {
-        return this.mapArray(matrixRCNs, (rcn) => {
-            const rcnReference = GTINValidator.parseVariableMeasureRCN(format, rcn);
-            return [rcnReference.itemReference, rcnReference.priceOrWeight];
-        });
-    }
-};
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(zeroSuppressibleGTIN12ParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "zeroSuppressGTIN12", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(zeroSuppressedGTIN12ParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "zeroExpandGTIN12", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(indicatorDigitParameterDescriptor)),
-    __param(1, ProxyParameter(convertGTINParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "convertToGTIN14", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(normalizeGTINParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "normalizeGTIN", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(validateGTINParameterDescriptor)),
-    __param(1, ProxyParameter(gtinLevelParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "validateGTIN", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(validateGTIN14ParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "validateGTIN14", null);
-__decorate([
-    ProxyMethod({
-        type: Types.Number,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(rcnFormatParameterDescriptor)),
-    __param(1, ProxyParameter(rcnParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "parseVariableMeasureRCN", null);
-GTINValidatorStaticProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1"
-    })
-], GTINValidatorStaticProxy);
-export { GTINValidatorStaticProxy };
-let GLNValidatorProxy = class GLNValidatorProxy extends NonGTINNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GLN_VALIDATOR);
-    }
-};
-GLNValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GLN"
-    })
-], GLNValidatorProxy);
-export { GLNValidatorProxy };
-let SSCCValidatorProxy = class SSCCValidatorProxy extends NonGTINNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, SSCC_VALIDATOR);
-    }
-};
-SSCCValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "SSCC"
-    })
-], SSCCValidatorProxy);
-export { SSCCValidatorProxy };
-let GRAIValidatorProxy = class GRAIValidatorProxy extends SerializableNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GRAI_VALIDATOR);
-    }
-};
-GRAIValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GRAI"
-    })
-], GRAIValidatorProxy);
-export { GRAIValidatorProxy };
-let GIAIValidatorProxy = class GIAIValidatorProxy extends NonNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GIAI_VALIDATOR);
-    }
-};
-GIAIValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GIAI"
-    })
-], GIAIValidatorProxy);
-export { GIAIValidatorProxy };
-let GSRNValidatorProxy = class GSRNValidatorProxy extends NonGTINNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GSRN_VALIDATOR);
-    }
-};
-GSRNValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GSRN"
-    })
-], GSRNValidatorProxy);
-export { GSRNValidatorProxy };
-let GDTIValidatorProxy = class GDTIValidatorProxy extends SerializableNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GDTI_VALIDATOR);
-    }
-};
-GDTIValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GDTI"
-    })
-], GDTIValidatorProxy);
-export { GDTIValidatorProxy };
-let GINCValidatorProxy = class GINCValidatorProxy extends NonNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GINC_VALIDATOR);
-    }
-};
-GINCValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GINC"
-    })
-], GINCValidatorProxy);
-export { GINCValidatorProxy };
-let GSINValidatorProxy = class GSINValidatorProxy extends NonGTINNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GSIN_VALIDATOR);
-    }
-};
-GSINValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GSIN"
-    })
-], GSINValidatorProxy);
-export { GSINValidatorProxy };
-let GCNValidatorProxy = class GCNValidatorProxy extends SerializableNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GCN_VALIDATOR);
-    }
-};
-GCNValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GCN"
-    })
-], GCNValidatorProxy);
-export { GCNValidatorProxy };
-let CPIDValidatorProxy = class CPIDValidatorProxy extends NonNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, CPID_VALIDATOR);
-    }
-};
-CPIDValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "CPID"
-    })
-], CPIDValidatorProxy);
-export { CPIDValidatorProxy };
-let GMNValidatorProxy = class GMNValidatorProxy extends NonNumericIdentifierValidatorProxy {
-    constructor(appExtension) {
-        super(appExtension, GMN_VALIDATOR);
-    }
-};
-GMNValidatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GMN"
-    })
-], GMNValidatorProxy);
-export { GMNValidatorProxy };
-const prefixParameterDescriptor = {
-    name: "prefix",
-    type: Types.String,
-    isMatrix: false,
-    isRequired: true
-};
-const prefixTypeParameterDescriptor = {
-    name: "prefixType",
-    type: Types.Number,
-    isMatrix: false,
-    isRequired: false
-};
-const tweakFactorParameterDescriptor = {
-    name: "tweakFactor",
-    type: Types.Number,
-    isMatrix: false,
-    isRequired: false
-};
-const prefixDefinitionParameterDescriptor = {
-    name: "prefixDefinition",
-    type: Types.Any,
-    isMatrix: true,
-    isRequired: true
-};
-const prefixDefinitionGS1UPCParameterDescriptor = {
-    extendsDescriptor: prefixDefinitionParameterDescriptor,
-    name: "prefixDefinitionGS1UPC"
-};
-const prefixDefinitionAnyParameterDescriptor = {
-    extendsDescriptor: prefixDefinitionParameterDescriptor,
-    name: "prefixDefinitionAny"
-};
-let PrefixManagerProxy = class PrefixManagerProxy extends LibProxy {
-    definePrefix(prefix, prefixType, tweakFactor) {
-        // Parameters will be validated by IdentifierCreatorProxy.getCreator().
-        return [[prefix, prefixType, tweakFactor]];
-    }
-};
-__decorate([
-    ProxyMethod({
-        type: Types.Any,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(prefixParameterDescriptor)),
-    __param(1, ProxyParameter(prefixTypeParameterDescriptor)),
-    __param(2, ProxyParameter(tweakFactorParameterDescriptor))
-], PrefixManagerProxy.prototype, "definePrefix", null);
-PrefixManagerProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1"
-    })
-], PrefixManagerProxy);
-export { PrefixManagerProxy };
-class IdentifierCreatorProxy extends LibProxy {
-    static PREFIX_TYPES = [PrefixTypes.GS1CompanyPrefix, PrefixTypes.UPCCompanyPrefix, PrefixTypes.GS18Prefix];
-    _getCreator;
-    constructor(appExtension, getCreator) {
-        super(appExtension);
-        this._getCreator = getCreator;
-    }
-    getCreator(prefixDefinition) {
-        const reducedPrefixDefinition = prefixDefinition.length === 1 ?
-            // Prefix definition is horizontal.
-            prefixDefinition[0] :
-            // Prefix definition is vertical.
-            prefixDefinition.map((prefixDefinitionRow) => {
-                if (prefixDefinitionRow.length !== 1) {
-                    throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixDefinitionMustBeOneDimensional"));
-                }
-                return prefixDefinitionRow[0];
-            });
-        if (reducedPrefixDefinition.length > 3) {
-            throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixDefinitionMustHaveMaximumThreeElements"));
-        }
-        const prefix = reducedPrefixDefinition[0];
-        if (typeof prefix !== "string") {
-            throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixMustBeString"));
-        }
-        const prefixTypeIndex = reducedPrefixDefinition[1] ?? 0;
-        if (typeof prefixTypeIndex !== "number" || prefixTypeIndex < 0 || prefixTypeIndex >= IdentifierCreatorProxy.PREFIX_TYPES.length) {
-            throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.prefixTypeMustBeNumber", {
-                maximumPrefixType: IdentifierCreatorProxy.PREFIX_TYPES.length - 1
-            }));
-        }
-        const prefixManager = PrefixManager.get(IdentifierCreatorProxy.PREFIX_TYPES[prefixTypeIndex], prefix);
-        const tweakFactor = reducedPrefixDefinition[2];
-        if (!isNullish(tweakFactor)) {
-            if (typeof tweakFactor !== "number") {
-                throw new RangeError(i18nextAppExtension.t("IdentifierCreatorProxy.tweakFactorMustBeNumber"));
-            }
-            prefixManager.tweakFactor = tweakFactor;
-        }
-        else {
-            prefixManager.resetTweakFactor();
-        }
-        return this._getCreator(prefixManager);
-    }
-}
-const sparseParameterDescriptor = {
-    name: "sparse",
-    type: Types.Boolean,
-    isMatrix: false,
-    isRequired: false
-};
-class NumericIdentifierCreatorProxy extends IdentifierCreatorProxy {
-    create(prefixDefinition, matrixValues, sparse) {
-        const creator = this.getCreator(prefixDefinition);
-        const sparseOrUndefined = sparse ?? undefined;
-        return this.mapMatrix(matrixValues, value => creator.create(value, sparseOrUndefined));
-    }
-    createSequence(prefixDefinition, startValue, count, sparse) {
-        this.appExtension.validateSequenceCount(count);
-        return LibProxy.matrixResult(this.getCreator(prefixDefinition).create(new Sequence(startValue, count), sparse ?? undefined));
-    }
-    createAll(prefixDefinition) {
-        const creator = this.getCreator(prefixDefinition);
-        this.appExtension.validateSequenceCount(creator.capacity);
-        return LibProxy.matrixResult(creator.createAll());
-    }
-}
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-    __param(1, ProxyParameter(valueParameterDescriptor)),
-    __param(2, ProxyParameter(sparseParameterDescriptor))
-], NumericIdentifierCreatorProxy.prototype, "create", null);
-__decorate([
-    ProxyMethod({
-        infixBefore: "Sequence",
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-    __param(1, ProxyParameter(startValueParameterDescriptor)),
-    __param(2, ProxyParameter(countParameterDescriptor)),
-    __param(3, ProxyParameter(sparseParameterDescriptor))
-], NumericIdentifierCreatorProxy.prototype, "createSequence", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor))
-], NumericIdentifierCreatorProxy.prototype, "createAll", null);
-class NonGTINNumericIdentifierCreatorProxy extends NumericIdentifierCreatorProxy {
-}
-const singleValueParameterDescriptor = {
-    extendsDescriptor: valueParameterDescriptor,
-    isMatrix: false
-};
-const baseIdentifierParameterDescriptor = {
-    extendsDescriptor: identifierParameterDescriptor,
-    name: "baseIdentifier",
-    isMatrix: false
-};
-const serialComponentParameterDescriptor = {
-    name: "serialComponent",
-    type: Types.String,
-    isMatrix: true,
-    isRequired: true
-};
-class SerializableNumericIdentifierCreatorProxy extends NonGTINNumericIdentifierCreatorProxy {
-    createSerialized(prefixDefinition, value, matrixSerialComponents, sparse) {
-        const creator = this.getCreator(prefixDefinition);
-        const sparseOrUndefined = sparse ?? undefined;
-        return this.mapMatrix(matrixSerialComponents, serialComponent => creator.createSerialized(value, serialComponent, sparseOrUndefined));
-    }
-    concatenate(baseIdentifier, matrixSerialComponents) {
-        const creator = this.getCreator([[baseIdentifier.substring(0, !baseIdentifier.startsWith("0") ? PrefixValidator.GS1_COMPANY_PREFIX_MINIMUM_LENGTH : PrefixValidator.UPC_COMPANY_PREFIX_MINIMUM_LENGTH + 1), PrefixTypes.GS1CompanyPrefix]]);
-        return this.mapMatrix(matrixSerialComponents, serialComponent => creator.concatenate(baseIdentifier, serialComponent));
-    }
-}
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-    __param(1, ProxyParameter(singleValueParameterDescriptor)),
-    __param(2, ProxyParameter(serialComponentParameterDescriptor)),
-    __param(3, ProxyParameter(sparseParameterDescriptor))
-], SerializableNumericIdentifierCreatorProxy.prototype, "createSerialized", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(baseIdentifierParameterDescriptor)),
-    __param(1, ProxyParameter(serialComponentParameterDescriptor))
-], SerializableNumericIdentifierCreatorProxy.prototype, "concatenate", null);
-const referenceParameterDescriptor = {
-    name: "reference",
-    type: Types.String,
-    isMatrix: true,
-    isRequired: true
-};
-class NonNumericIdentifierCreatorProxy extends IdentifierCreatorProxy {
-    create(prefixDefinition, matrixReferences) {
-        const creator = this.getCreator(prefixDefinition);
-        return this.mapMatrix(matrixReferences, reference => creator.create(reference));
-    }
-}
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true
-    }),
-    __param(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-    __param(1, ProxyParameter(referenceParameterDescriptor))
-], NonNumericIdentifierCreatorProxy.prototype, "create", null);
-let GTINCreatorProxy = class GTINCreatorProxy extends NumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.gtinCreator);
-    }
-    createGTIN14(indicatorDigit, prefixDefinition, matrixValues, sparse) {
-        const creator = this.getCreator(prefixDefinition);
-        const sparseOrUndefined = sparse ?? undefined;
-        return this.mapMatrix(matrixValues, value => creator.createGTIN14(indicatorDigit, value, sparseOrUndefined));
-    }
-    createVariableMeasureRCN(format, itemReference, matrixPricesOrWeights) {
-        return this.mapMatrix(matrixPricesOrWeights, priceOrWeight => GTINCreator.createVariableMeasureRCN(format, itemReference, priceOrWeight));
-    }
-};
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true,
-        ignoreInfix: true
-    }),
-    __param(0, ProxyParameter(indicatorDigitParameterDescriptor)),
-    __param(1, ProxyParameter(prefixDefinitionAnyParameterDescriptor)),
-    __param(2, ProxyParameter(valueParameterDescriptor)),
-    __param(3, ProxyParameter(sparseParameterDescriptor))
-], GTINCreatorProxy.prototype, "createGTIN14", null);
-__decorate([
-    ProxyMethod({
-        type: Types.String,
-        isMatrix: true,
-        ignoreInfix: true
-    }),
-    __param(0, ProxyParameter(rcnFormatParameterDescriptor)),
-    __param(1, ProxyParameter(rcnItemReferenceParameterDescriptor)),
-    __param(2, ProxyParameter(rcnPriceOrWeightParameterDescriptor))
-], GTINCreatorProxy.prototype, "createVariableMeasureRCN", null);
-GTINCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GTIN",
-        replaceParameterDescriptors: [
-            {
-                name: expandParameterDescriptor(prefixDefinitionGS1UPCParameterDescriptor).name,
-                replacement: prefixDefinitionAnyParameterDescriptor
-            }
-        ]
-    })
-], GTINCreatorProxy);
-export { GTINCreatorProxy };
-let GLNCreatorProxy = class GLNCreatorProxy extends NonGTINNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.glnCreator);
-    }
-};
-GLNCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GLN"
-    })
-], GLNCreatorProxy);
-export { GLNCreatorProxy };
-let SSCCCreatorProxy = class SSCCCreatorProxy extends NonGTINNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.ssccCreator);
-    }
-};
-SSCCCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "SSCC"
-    })
-], SSCCCreatorProxy);
-export { SSCCCreatorProxy };
-let GRAICreatorProxy = class GRAICreatorProxy extends SerializableNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.graiCreator);
-    }
-};
-GRAICreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GRAI"
-    })
-], GRAICreatorProxy);
-export { GRAICreatorProxy };
-let GIAICreatorProxy = class GIAICreatorProxy extends NonNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.giaiCreator);
-    }
-};
-GIAICreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GIAI"
-    })
-], GIAICreatorProxy);
-export { GIAICreatorProxy };
-let GSRNCreatorProxy = class GSRNCreatorProxy extends NonGTINNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.gsrnCreator);
-    }
-};
-GSRNCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GSRN"
-    })
-], GSRNCreatorProxy);
-export { GSRNCreatorProxy };
-let GDTICreatorProxy = class GDTICreatorProxy extends SerializableNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.gdtiCreator);
-    }
-};
-GDTICreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GDTI"
-    })
-], GDTICreatorProxy);
-export { GDTICreatorProxy };
-let GINCCreatorProxy = class GINCCreatorProxy extends NonNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.gincCreator);
-    }
-};
-GINCCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GINC"
-    })
-], GINCCreatorProxy);
-export { GINCCreatorProxy };
-let GSINCreatorProxy = class GSINCreatorProxy extends NonGTINNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.gsinCreator);
-    }
-};
-GSINCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GSIN"
-    })
-], GSINCreatorProxy);
-export { GSINCreatorProxy };
-let GCNCreatorProxy = class GCNCreatorProxy extends SerializableNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.gcnCreator);
-    }
-};
-GCNCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GCN"
-    })
-], GCNCreatorProxy);
-export { GCNCreatorProxy };
-let CPIDCreatorProxy = class CPIDCreatorProxy extends NonNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.cpidCreator);
-    }
-};
-CPIDCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "CPID"
-    })
-], CPIDCreatorProxy);
-export { CPIDCreatorProxy };
-let GMNCreatorProxy = class GMNCreatorProxy extends NonNumericIdentifierCreatorProxy {
-    constructor(appExtension) {
-        super(appExtension, prefixManager => prefixManager.gmnCreator);
-    }
-};
-GMNCreatorProxy = __decorate([
-    ProxyClass({
-        namespace: "GS1",
-        methodInfix: "GMN"
-    })
-], GMNCreatorProxy);
-export { GMNCreatorProxy };
-//# sourceMappingURL=identifier-proxy.js.map