@aidc-toolkit/app-extension 1.0.27-beta → 1.0.31-beta

package/dist/index.js

@@ -1,23 +1,54 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
-var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/locale/i18n.ts
@@ -1655,91 +1686,279 @@ var Types = {
    */
   Any: 3
 };
+
+// src/app-utility-proxy.ts
+import { isNullish } from "@aidc-toolkit/core";
+
+// src/proxy.ts
+import {
+  getLogger,
+  LogLevels,
+  omit
+} from "@aidc-toolkit/core";
 function expandParameterDescriptor(parameterDescriptor) {
   return !("extendsDescriptor" in parameterDescriptor) ? parameterDescriptor : {
     ...expandParameterDescriptor(parameterDescriptor.extendsDescriptor),
     ...parameterDescriptor
   };
 }
-var pendingParameterDescriptors = [];
-var classMethodsDescriptorsMap = /* @__PURE__ */ new Map();
-var classDescriptorsMap = /* @__PURE__ */ new Map();
-function ProxyParameter(parameterDescriptor) {
-  return (_target, _propertyKey, parameterIndex) => {
-    pendingParameterDescriptors[parameterIndex] = parameterDescriptor;
-  };
-}
-function ProxyMethod(methodDescriptor) {
-  return (target, propertyKey, propertyDescriptor) => {
-    const declarationClassName = target.constructor.name;
-    if (typeof propertyDescriptor.value !== "function") {
-      throw new Error(`${declarationClassName}.${propertyKey} is not a method`);
+var Proxy2 = class _Proxy {
+  /**
+   * Logger.
+   */
+  // TODO Add configuration parameter to output JSON.
+  // TODO Change this to LogLevels.Trace when configuration available.
+  #logger = getLogger(LogLevels.Info);
+  /**
+   * Abstract class descriptors map, keyed on declaration class name. Abstract classes are not used directly by target
+   * applications.
+   */
+  #abstractClassDescriptorsMap = /* @__PURE__ */ new Map();
+  /**
+   * Concrete class descriptors map, keyed on declaration class name.
+   */
+  #concreteClassDescriptorsMap = /* @__PURE__ */ new Map();
+  /**
+   * Interim object.
+   */
+  #interim = void 0;
+  /**
+   * Get the proper JSON representation of a value.
+   *
+   * @param value
+   * Value.
+   *
+   * @returns
+   * Replacement value.
+   */
+  static #jsonValue(value) {
+    let replacementValue;
+    switch (typeof value) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "undefined":
+        replacementValue = value;
+        break;
+      case "bigint":
+        replacementValue = value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER ? Number(value) : value.toString(10);
+        break;
+      case "object":
+        if (value === null) {
+          replacementValue = value;
+        } else if (Array.isArray(value)) {
+          replacementValue = value.map((entry) => _Proxy.#jsonValue(entry));
+        } else {
+          replacementValue = Object.fromEntries(Object.entries(value).map(([k, v]) => [k, _Proxy.#jsonValue(v)]));
+        }
+        break;
+      case "symbol":
+      case "function":
+        throw new Error(`Unsupported ${typeof value} value type`);
     }
-    const parameterCount = propertyDescriptor.value.length - (!(methodDescriptor.requiresContext ?? false) ? 0 : 1);
-    let anyOptional = false;
-    for (let index = 0; index < parameterCount; index++) {
-      const parameterDescriptor = expandParameterDescriptor(pendingParameterDescriptors[index]);
-      if (typeof parameterDescriptor === "undefined") {
-        throw new Error(`Missing parameter descriptor at index ${index} of ${declarationClassName}.${propertyKey}`);
+    return replacementValue;
+  }
+  /**
+   * Describe a proxy class.
+   *
+   * @template T
+   * Proxy class type.
+   *
+   * @template IsAbstract
+   * True if the proxy class is abstract.
+   *
+   * @template TConstructor
+   * Proxy class constructor type.
+   *
+   * @template TProxyClassConstructor
+   * Narrowed proxy class constructor type.
+   *
+   * @param isAbstract
+   * True if class is abstract.
+   *
+   * @param decoratorClassDescriptor
+   * Class descriptor.
+   *
+   * @returns
+   * Function with which to decorate the class.
+   */
+  describeClass(isAbstract, decoratorClassDescriptor = {}) {
+    const interimClassDescriptor = decoratorClassDescriptor.replaceParameterDescriptors === void 0 ? omit(decoratorClassDescriptor, "replaceParameterDescriptors") : {
+      ...decoratorClassDescriptor,
+      replaceParameterDescriptors: decoratorClassDescriptor.replaceParameterDescriptors.map((replaceParameterDescriptor) => ({
+        ...replaceParameterDescriptor,
+        replacement: expandParameterDescriptor(replaceParameterDescriptor.replacement)
+      }))
+    };
+    const interim = {
+      classDescriptor: interimClassDescriptor,
+      methodDescriptors: []
+    };
+    this.#interim = interim;
+    return (Target, context) => {
+      const name = context.name;
+      if (typeof name !== "string") {
+        throw new Error(`${String(name)} has an invalid name`);
       }
-      if (!parameterDescriptor.isRequired) {
-        anyOptional = true;
-      } else if (anyOptional) {
-        throw new Error(`Parameter descriptor ${parameterDescriptor.name} at index ${index} of ${declarationClassName}.${propertyKey} is required but prior parameter descriptor ${pendingParameterDescriptors[index - 1].name} is optional`);
+      const namespacePrefix = decoratorClassDescriptor.namespace === void 0 ? "" : `${decoratorClassDescriptor.namespace}.`;
+      const namespaceClassName = `${namespacePrefix}${name}`;
+      const abstractClassDescriptorsMap = this.#abstractClassDescriptorsMap;
+      const concreteClassDescriptorsMap = this.#concreteClassDescriptorsMap;
+      if (abstractClassDescriptorsMap.has(namespaceClassName) || concreteClassDescriptorsMap.has(namespaceClassName)) {
+        throw new Error(`Duplicate class ${namespaceClassName}`);
       }
-    }
-    let methodDescriptors = classMethodsDescriptorsMap.get(declarationClassName);
-    if (methodDescriptors === void 0) {
-      methodDescriptors = [];
-      classMethodsDescriptorsMap.set(declarationClassName, methodDescriptors);
-    }
-    methodDescriptors.push({
-      name: propertyKey,
-      ...methodDescriptor,
-      parameterDescriptors: pendingParameterDescriptors
-    });
-    pendingParameterDescriptors = [];
-  };
-}
-function ProxyClass(classDescriptor = {}) {
-  return (classType) => {
-    const methodDescriptorsMap = /* @__PURE__ */ new Map();
-    function buildMethodDescriptorsMap(classType2) {
-      const baseClassType = Object.getPrototypeOf(classType2);
-      if (baseClassType !== LibProxy) {
-        buildMethodDescriptorsMap(baseClassType);
+      let baseClassType = Target;
+      let baseClassDescriptor;
+      do {
+        baseClassType = Object.getPrototypeOf(baseClassType);
+        const namespaceBaseClassName = `${namespacePrefix}${baseClassType.name}`;
+        baseClassDescriptor = abstractClassDescriptorsMap.get(namespaceBaseClassName) ?? abstractClassDescriptorsMap.get(baseClassType.name) ?? concreteClassDescriptorsMap.get(namespaceBaseClassName) ?? concreteClassDescriptorsMap.get(baseClassType.name);
+      } while (baseClassType !== LibProxy && baseClassDescriptor === void 0);
+      let interimMethodDescriptors;
+      if (baseClassDescriptor !== void 0) {
+        const baseClassMethodDescriptors = baseClassDescriptor.methodDescriptors;
+        const replaceParameterDescriptors = decoratorClassDescriptor.replaceParameterDescriptors;
+        if (replaceParameterDescriptors !== void 0) {
+          const replacementParameterDescriptorsMap = new Map(replaceParameterDescriptors.map((replaceParameterDescriptor) => [replaceParameterDescriptor.name, expandParameterDescriptor(replaceParameterDescriptor.replacement)]));
+          interimMethodDescriptors = baseClassMethodDescriptors.map((baseClassMethodDescriptor) => ({
+            ...baseClassMethodDescriptor,
+            parameterDescriptors: baseClassMethodDescriptor.parameterDescriptors.map((parameterDescriptor) => replacementParameterDescriptorsMap.get(parameterDescriptor.name) ?? parameterDescriptor)
+          }));
+        } else {
+          interimMethodDescriptors = baseClassMethodDescriptors.slice();
+        }
+      } else {
+        interimMethodDescriptors = [];
       }
-      const classMethodDescriptors = classMethodsDescriptorsMap.get(classType2.name);
-      if (classMethodDescriptors !== void 0) {
-        for (const classMethodDescriptor of classMethodDescriptors) {
-          methodDescriptorsMap.set(classMethodDescriptor.name, classMethodDescriptor);
+      for (const classInterimMethodDescriptor of interim.methodDescriptors) {
+        const existingIndex = interimMethodDescriptors.findIndex((interimMethodDescriptor) => interimMethodDescriptor.name === classInterimMethodDescriptor.name);
+        if (existingIndex !== -1) {
+          interimMethodDescriptors[existingIndex] = classInterimMethodDescriptor;
+        } else {
+          interimMethodDescriptors.push(classInterimMethodDescriptor);
         }
       }
-    }
-    buildMethodDescriptorsMap(classType);
-    let methodDescriptors;
-    if (classDescriptor.replaceParameterDescriptors !== void 0) {
-      const replacementParameterDescriptorsMap = new Map(classDescriptor.replaceParameterDescriptors.map((replaceParameterDescriptor) => [replaceParameterDescriptor.name, replaceParameterDescriptor.replacement]));
-      methodDescriptors = Array.from(methodDescriptorsMap.values()).map((methodDescriptor) => ({
-        ...methodDescriptor,
-        parameterDescriptors: methodDescriptor.parameterDescriptors.map((parameterDescriptor) => replacementParameterDescriptorsMap.get(expandParameterDescriptor(parameterDescriptor).name) ?? parameterDescriptor)
-      }));
-    } else {
-      methodDescriptors = Array.from(methodDescriptorsMap.values());
-    }
-    classDescriptorsMap.set(classType.name, {
-      name: classType.name,
-      ...classDescriptor,
-      methodDescriptors
-    });
-  };
-}
-function getClassDescriptorsMap() {
-  return classDescriptorsMap;
-}
+      const methodDescriptors = [];
+      const methodInfix = decoratorClassDescriptor.methodInfix;
+      for (const interimMethodDescriptor of interimMethodDescriptors) {
+        const methodName = interimMethodDescriptor.name;
+        const infixBefore = interimMethodDescriptor.infixBefore;
+        let functionName;
+        if (methodInfix === void 0 || interimMethodDescriptor.ignoreInfix === true) {
+          functionName = methodName;
+        } else if (infixBefore === void 0) {
+          functionName = `${methodName}${methodInfix}`;
+        } else {
+          const insertIndex = methodName.indexOf(infixBefore);
+          if (insertIndex === -1) {
+            throw new Error(`Cannot find "${infixBefore}" in method ${methodName}`);
+          }
+          functionName = `${methodName.substring(0, insertIndex)}${methodInfix}${methodName.substring(insertIndex)}`;
+        }
+        const namespaceFunctionName = `${namespacePrefix}${functionName}`;
+        const methodDescriptor = {
+          ...interimMethodDescriptor,
+          functionName,
+          namespaceFunctionName
+        };
+        methodDescriptors.push(methodDescriptor);
+      }
+      const objectNameGroups = /^(?<namespaceFirstWord>[A-Z]+[0-9]*|[A-Z][^A-Z.]*)(?<namespaceRemaining>[A-Z][^.]*|)\.?(?<className>[A-Z].*|)$/.exec(namespaceClassName)?.groups;
+      if (objectNameGroups === void 0) {
+        throw new Error(`${namespaceClassName} is not a valid namespace-qualified class name`);
+      }
+      const classDescriptor = {
+        name,
+        ...interimClassDescriptor,
+        namespaceClassName,
+        objectName: `${objectNameGroups["namespaceFirstWord"].toLowerCase()}${objectNameGroups["namespaceRemaining"]}${objectNameGroups["className"]}`,
+        methodDescriptors
+      };
+      (isAbstract ? abstractClassDescriptorsMap : concreteClassDescriptorsMap).set(namespaceClassName, classDescriptor);
+      const methodDescriptorsMap = /* @__PURE__ */ new Map();
+      for (const methodDescriptor of methodDescriptors) {
+        methodDescriptorsMap.set(methodDescriptor.name, methodDescriptor);
+      }
+      this.#interim = void 0;
+      const logger = this.#logger;
+      return class extends Target {
+        /**
+         * @inheritDoc
+         */
+        log(logLevel, methodName, args, result) {
+          const methodDescriptor = methodDescriptorsMap.get(methodName);
+          logger.log(logLevel, "", JSON.stringify({
+            namespace: decoratorClassDescriptor.namespace,
+            className: name,
+            methodName,
+            functionName: methodDescriptor.functionName,
+            parameters: methodDescriptor.parameterDescriptors.map((parameterDescriptor, index) => ({
+              name: parameterDescriptor.name,
+              value: args[index]
+            })),
+            result: _Proxy.#jsonValue(result)
+          }, null, 2));
+        }
+      };
+    };
+  }
+  /**
+   * Describe a proxy method.
+   *
+   * @template TFunction
+   * Function type.
+   *
+   * @param decoratorMethodDescriptor
+   * Method descriptor.
+   *
+   * @returns
+   * Function with which to decorate the method.
+   */
+  describeMethod(decoratorMethodDescriptor) {
+    return (target, context) => {
+      const name = context.name;
+      if (this.#interim === void 0 || typeof name !== "string" || context.static || context.private) {
+        throw new Error(`${String(name)} is not defined within a supported class, has an invalid name, is static, or is private`);
+      }
+      let anyOptional = false;
+      const parameterDescriptors = decoratorMethodDescriptor.parameterDescriptors.map((decoratorParameterDescriptor) => {
+        const parameterDescriptor = expandParameterDescriptor(decoratorParameterDescriptor);
+        if (!parameterDescriptor.isRequired) {
+          anyOptional = true;
+        } else if (anyOptional) {
+          throw new Error(`Parameter ${parameterDescriptor.name} descriptor of method ${name} is required but prior parameter descriptor is optional`);
+        }
+        return parameterDescriptor;
+      });
+      this.#interim.methodDescriptors.push({
+        name,
+        ...decoratorMethodDescriptor,
+        parameterDescriptors
+      });
+      return function methodProxy(...args) {
+        const targetLogger = this;
+        let result;
+        try {
+          result = target.call(this, ...args);
+          targetLogger.log(LogLevels.Info, name, args, result);
+        } catch (e) {
+          targetLogger.log(LogLevels.Error, name, args, e instanceof Error ? `${e.name}: ${e.message}` : `Unknown exception: ${String(e)}`);
+          throw e;
+        }
+        return result;
+      };
+    };
+  }
+  /**
+   * Get the class descriptors map.
+   */
+  get classDescriptorsMap() {
+    return this.#concreteClassDescriptorsMap;
+  }
+};
+var proxy = new Proxy2();
 
 // src/app-utility-proxy.ts
-import { isNullish } from "@aidc-toolkit/core";
 var spillMatrix = {
   name: "spillMatrix",
   type: Types.Any,
@@ -1762,10 +1981,26 @@ var spillMaximumHeightParameterDescriptor = {
   sortOrder: 1,
   name: "spillMaximumHeight"
 };
-var _AppUtilityProxy_instances, defaultMaximums_fn;
-var AppUtilityProxy = class extends LibProxy {
+var _hSpill_dec, _vSpill_dec, _version_dec, _a, _AppUtilityProxy_decorators, _init, _AppUtilityProxy_instances, defaultMaximums_fn;
+_AppUtilityProxy_decorators = [proxy.describeClass(false)];
+var AppUtilityProxy = class extends (_a = LibProxy, _version_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: false,
+  parameterDescriptors: []
+})], _vSpill_dec = [proxy.describeMethod({
+  requiresContext: true,
+  type: Types.Any,
+  isMatrix: true,
+  parameterDescriptors: [spillMatrix, spillMaximumWidthParameterDescriptor, spillMaximumHeightParameterDescriptor]
+})], _hSpill_dec = [proxy.describeMethod({
+  requiresContext: true,
+  type: Types.Any,
+  isMatrix: true,
+  parameterDescriptors: [spillMatrix, spillMaximumHeightParameterDescriptor, spillMaximumWidthParameterDescriptor]
+})], _a) {
   constructor() {
     super(...arguments);
+    __runInitializers(_init, 5, this);
     __privateAdd(this, _AppUtilityProxy_instances);
   }
   version() {
@@ -1786,7 +2021,7 @@ var AppUtilityProxy = class extends LibProxy {
     if (hLength > 1 && hLength <= maximumArea) {
       let spillWidth = Math.min(Math.ceil(Math.sqrt(maximumArea)), maximumDimensions.width);
       if (Number.isInteger(Math.log10(hLength))) {
-        const spillWidth10 = Math.pow(10, Math.floor(Math.log10(spillWidth)));
+        const spillWidth10 = 10 ** Math.floor(Math.log10(spillWidth));
         if (hLength / spillWidth10 <= maximumDimensions.height) {
           spillWidth = spillWidth10;
         }
@@ -1819,7 +2054,7 @@ var AppUtilityProxy = class extends LibProxy {
     if (vLength > 1 && vLength <= maximumArea) {
       let spillHeight = Math.min(Math.ceil(Math.sqrt(maximumArea)), maximumDimensions.height);
       if (Number.isInteger(Math.log10(vLength))) {
-        const spillHeight10 = Math.pow(10, Math.floor(Math.log10(spillHeight)));
+        const spillHeight10 = 10 ** Math.floor(Math.log10(spillHeight));
         if (vLength / spillHeight10 <= maximumDimensions.width) {
           spillHeight = spillHeight10;
         }
@@ -1838,6 +2073,7 @@ var AppUtilityProxy = class extends LibProxy {
     return result;
   }
 };
+_init = __decoratorStart(_a);
 _AppUtilityProxy_instances = new WeakSet();
 defaultMaximums_fn = async function(maximumDimensions, invocationContext) {
   if (isNullish(invocationContext)) {
@@ -1860,35 +2096,11 @@ defaultMaximums_fn = async function(maximumDimensions, invocationContext) {
     height: definedMaximumHeight
   };
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: false
-  })
-], AppUtilityProxy.prototype, "version", 1);
-__decorateClass([
-  ProxyMethod({
-    requiresContext: true,
-    type: Types.Any,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(spillMatrix)),
-  __decorateParam(1, ProxyParameter(spillMaximumWidthParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(spillMaximumHeightParameterDescriptor))
-], AppUtilityProxy.prototype, "vSpill", 1);
-__decorateClass([
-  ProxyMethod({
-    requiresContext: true,
-    type: Types.Any,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(spillMatrix)),
-  __decorateParam(1, ProxyParameter(spillMaximumHeightParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(spillMaximumWidthParameterDescriptor))
-], AppUtilityProxy.prototype, "hSpill", 1);
-AppUtilityProxy = __decorateClass([
-  ProxyClass()
-], AppUtilityProxy);
+__decorateElement(_init, 1, "version", _version_dec, AppUtilityProxy);
+__decorateElement(_init, 1, "vSpill", _vSpill_dec, AppUtilityProxy);
+__decorateElement(_init, 1, "hSpill", _hSpill_dec, AppUtilityProxy);
+AppUtilityProxy = __decorateElement(_init, 0, "AppUtilityProxy", _AppUtilityProxy_decorators, AppUtilityProxy);
+__runInitializers(_init, 1, AppUtilityProxy);
 
 // src/utility/index.ts
 var utility_exports = {};
@@ -1941,7 +2153,28 @@ var transformedValueParameterDescriptor = {
   extendsDescriptor: valueParameterDescriptor,
   name: "transformedValue"
 };
-var TransformerProxy = class extends LibProxy {
+var _reverse_dec, _forwardSequence_dec, _forward_dec, _a2, _TransformerProxy_decorators, _init2;
+_TransformerProxy_decorators = [proxy.describeClass(false, {
+  methodInfix: "Transform"
+})];
+var TransformerProxy = class extends (_a2 = LibProxy, _forward_dec = [proxy.describeMethod({
+  type: Types.Number,
+  isMatrix: true,
+  parameterDescriptors: [domainParameterDescriptor, valueParameterDescriptor, tweakParameterDescriptor]
+})], _forwardSequence_dec = [proxy.describeMethod({
+  infixBefore: "Sequence",
+  type: Types.Number,
+  isMatrix: true,
+  parameterDescriptors: [domainParameterDescriptor, startValueParameterDescriptor, countParameterDescriptor, tweakParameterDescriptor]
+})], _reverse_dec = [proxy.describeMethod({
+  type: Types.Number,
+  isMatrix: true,
+  parameterDescriptors: [domainParameterDescriptor, transformedValueParameterDescriptor, tweakParameterDescriptor]
+})], _a2) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init2, 5, this);
+  }
   forward(domain, matrixValues, tweak) {
     const transformer = Transformer.get(domain, tweak ?? void 0);
     return this.mapMatrix(matrixValues, (value) => this.mapBigInt(transformer.forward(value)));
@@ -1955,40 +2188,12 @@ var TransformerProxy = class extends LibProxy {
     return this.mapMatrix(matrixTransformedValues, (transformedValue) => this.mapBigInt(transformer.reverse(transformedValue)));
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.Number,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(domainParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(valueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(tweakParameterDescriptor))
-], TransformerProxy.prototype, "forward", 1);
-__decorateClass([
-  ProxyMethod({
-    infixBefore: "Sequence",
-    type: Types.Number,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(domainParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(startValueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(countParameterDescriptor)),
-  __decorateParam(3, ProxyParameter(tweakParameterDescriptor))
-], TransformerProxy.prototype, "forwardSequence", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.Number,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(domainParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(transformedValueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(tweakParameterDescriptor))
-], TransformerProxy.prototype, "reverse", 1);
-TransformerProxy = __decorateClass([
-  ProxyClass({
-    methodInfix: "Transform"
-  })
-], TransformerProxy);
+_init2 = __decoratorStart(_a2);
+__decorateElement(_init2, 1, "forward", _forward_dec, TransformerProxy);
+__decorateElement(_init2, 1, "forwardSequence", _forwardSequence_dec, TransformerProxy);
+__decorateElement(_init2, 1, "reverse", _reverse_dec, TransformerProxy);
+TransformerProxy = __decorateElement(_init2, 0, "TransformerProxy", _TransformerProxy_decorators, TransformerProxy);
+__runInitializers(_init2, 1, TransformerProxy);
 
 // src/utility/reg-exp-proxy.ts
 import { RegExpValidator } from "@aidc-toolkit/utility";
@@ -2030,7 +2235,23 @@ var errorMessageParameterDescriptor = {
   isMatrix: false,
   isRequired: false
 };
-var RegExpProxy = class extends StringProxy {
+var _isValid_dec, _validate_dec, _a3, _RegExpProxy_decorators, _init3;
+_RegExpProxy_decorators = [proxy.describeClass(false, {
+  methodInfix: "RegExp"
+})];
+var RegExpProxy = class extends (_a3 = StringProxy, _validate_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [regExpParameterDescriptor, validateSParameterDescriptor, errorMessageParameterDescriptor]
+})], _isValid_dec = [proxy.describeMethod({
+  type: Types.Boolean,
+  isMatrix: true,
+  parameterDescriptors: [regExpParameterDescriptor, validateSParameterDescriptor]
+})], _a3) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init3, 5, this);
+  }
   validate(regExp, matrixSs, errorMessage) {
     return this.validateString(new class extends RegExpValidator {
       createErrorMessage(s) {
@@ -2042,28 +2263,11 @@ var RegExpProxy = class extends StringProxy {
     return this.isValidString(this.validate(regExp, matrixSs, void 0));
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(regExpParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(validateSParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(errorMessageParameterDescriptor))
-], RegExpProxy.prototype, "validate", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.Boolean,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(regExpParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(validateSParameterDescriptor))
-], RegExpProxy.prototype, "isValid", 1);
-RegExpProxy = __decorateClass([
-  ProxyClass({
-    methodInfix: "RegExp"
-  })
-], RegExpProxy);
+_init3 = __decoratorStart(_a3);
+__decorateElement(_init3, 1, "validate", _validate_dec, RegExpProxy);
+__decorateElement(_init3, 1, "isValid", _isValid_dec, RegExpProxy);
+RegExpProxy = __decorateElement(_init3, 0, "RegExpProxy", _RegExpProxy_decorators, RegExpProxy);
+__runInitializers(_init3, 1, RegExpProxy);
 
 // src/utility/character-set-proxy.ts
 import {
@@ -2113,14 +2317,25 @@ var valueForSParameterDescriptor = {
   extendsDescriptor: sParameterDescriptor,
   name: "valueForS"
 };
-var CharacterSetValidatorProxy = class extends StringProxy {
-  #characterSetValidator;
+var _isValid_dec2, _validate_dec2, _a4, _CharacterSetValidatorProxy_decorators, _characterSetValidator, _init4;
+_CharacterSetValidatorProxy_decorators = [proxy.describeClass(true)];
+var CharacterSetValidatorProxy = class extends (_a4 = StringProxy, _validate_dec2 = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [validateSParameterDescriptor, exclusionNoneParameterDescriptor]
+})], _isValid_dec2 = [proxy.describeMethod({
+  type: Types.Boolean,
+  isMatrix: true,
+  parameterDescriptors: [validateSParameterDescriptor, exclusionNoneParameterDescriptor]
+})], _a4) {
   constructor(appExtension, characterSetValidator) {
     super(appExtension);
-    this.#characterSetValidator = characterSetValidator;
+    __runInitializers(_init4, 5, this);
+    __privateAdd(this, _characterSetValidator);
+    __privateSet(this, _characterSetValidator, characterSetValidator);
   }
   validate(matrixSs, exclusion) {
-    return this.validateString(this.#characterSetValidator, matrixSs, {
+    return this.validateString(__privateGet(this, _characterSetValidator), matrixSs, {
       exclusion: exclusion ?? void 0
     });
   }
@@ -2128,134 +2343,124 @@ var CharacterSetValidatorProxy = class extends StringProxy {
     return this.isValidString(this.validate(matrixSs, exclusion));
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(validateSParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(exclusionNoneParameterDescriptor))
-], CharacterSetValidatorProxy.prototype, "validate", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.Boolean,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(validateSParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(exclusionNoneParameterDescriptor))
-], CharacterSetValidatorProxy.prototype, "isValid", 1);
-var CharacterSetCreatorProxy = class extends CharacterSetValidatorProxy {
-  #characterSetCreator;
+_init4 = __decoratorStart(_a4);
+_characterSetValidator = new WeakMap();
+__decorateElement(_init4, 1, "validate", _validate_dec2, CharacterSetValidatorProxy);
+__decorateElement(_init4, 1, "isValid", _isValid_dec2, CharacterSetValidatorProxy);
+CharacterSetValidatorProxy = __decorateElement(_init4, 0, "CharacterSetValidatorProxy", _CharacterSetValidatorProxy_decorators, CharacterSetValidatorProxy);
+__runInitializers(_init4, 1, CharacterSetValidatorProxy);
+var _valueFor_dec, _createSequence_dec, _create_dec, _a5, _CharacterSetCreatorProxy_decorators, _characterSetCreator, _init5;
+_CharacterSetCreatorProxy_decorators = [proxy.describeClass(true)];
+var CharacterSetCreatorProxy = class extends (_a5 = CharacterSetValidatorProxy, _create_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [lengthParameterDescriptor, valueParameterDescriptor, exclusionNoneParameterDescriptor, tweakParameterDescriptor]
+})], _createSequence_dec = [proxy.describeMethod({
+  infixBefore: "Sequence",
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [lengthParameterDescriptor, startValueParameterDescriptor, countParameterDescriptor, exclusionNoneParameterDescriptor, tweakParameterDescriptor]
+})], _valueFor_dec = [proxy.describeMethod({
+  type: Types.Number,
+  isMatrix: true,
+  parameterDescriptors: [valueForSParameterDescriptor, exclusionNoneParameterDescriptor, tweakParameterDescriptor]
+})], _a5) {
   constructor(appExtension, characterSetCreator) {
     super(appExtension, characterSetCreator);
-    this.#characterSetCreator = characterSetCreator;
+    __runInitializers(_init5, 5, this);
+    __privateAdd(this, _characterSetCreator);
+    __privateSet(this, _characterSetCreator, characterSetCreator);
   }
   create(length, matrixValues, exclusion, tweak) {
     const exclusionOrUndefined = exclusion ?? void 0;
     const tweakOrUndefined = tweak ?? void 0;
-    return this.mapMatrix(matrixValues, (value) => this.#characterSetCreator.create(length, value, exclusionOrUndefined, tweakOrUndefined));
+    return this.mapMatrix(matrixValues, (value) => __privateGet(this, _characterSetCreator).create(length, value, exclusionOrUndefined, tweakOrUndefined));
   }
   createSequence(length, startValue, count, exclusion, tweak) {
     this.appExtension.validateSequenceCount(count);
     const exclusionOrUndefined = exclusion ?? void 0;
     const tweakOrUndefined = tweak ?? void 0;
-    return LibProxy.matrixResult(this.#characterSetCreator.create(length, new Sequence2(startValue, count), exclusionOrUndefined, tweakOrUndefined));
+    return LibProxy.matrixResult(__privateGet(this, _characterSetCreator).create(length, new Sequence2(startValue, count), exclusionOrUndefined, tweakOrUndefined));
   }
   valueFor(matrixSs, exclusion, tweak) {
     const exclusionOrUndefined = exclusion ?? void 0;
     const tweakOrUndefined = tweak ?? void 0;
-    return this.mapMatrix(matrixSs, (s) => this.mapBigInt(this.#characterSetCreator.valueFor(s, exclusionOrUndefined, tweakOrUndefined)));
-  }
-};
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(lengthParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(valueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(exclusionNoneParameterDescriptor)),
-  __decorateParam(3, ProxyParameter(tweakParameterDescriptor))
-], CharacterSetCreatorProxy.prototype, "create", 1);
-__decorateClass([
-  ProxyMethod({
-    infixBefore: "Sequence",
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(lengthParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(startValueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(countParameterDescriptor)),
-  __decorateParam(3, ProxyParameter(exclusionNoneParameterDescriptor)),
-  __decorateParam(4, ProxyParameter(tweakParameterDescriptor))
-], CharacterSetCreatorProxy.prototype, "createSequence", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.Number,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(valueForSParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(exclusionNoneParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(tweakParameterDescriptor))
-], CharacterSetCreatorProxy.prototype, "valueFor", 1);
-var NumericProxy = class extends CharacterSetCreatorProxy {
+    return this.mapMatrix(matrixSs, (s) => this.mapBigInt(__privateGet(this, _characterSetCreator).valueFor(s, exclusionOrUndefined, tweakOrUndefined)));
+  }
+};
+_init5 = __decoratorStart(_a5);
+_characterSetCreator = new WeakMap();
+__decorateElement(_init5, 1, "create", _create_dec, CharacterSetCreatorProxy);
+__decorateElement(_init5, 1, "createSequence", _createSequence_dec, CharacterSetCreatorProxy);
+__decorateElement(_init5, 1, "valueFor", _valueFor_dec, CharacterSetCreatorProxy);
+CharacterSetCreatorProxy = __decorateElement(_init5, 0, "CharacterSetCreatorProxy", _CharacterSetCreatorProxy_decorators, CharacterSetCreatorProxy);
+__runInitializers(_init5, 1, CharacterSetCreatorProxy);
+var _NumericProxy_decorators, _init6, _a6;
+_NumericProxy_decorators = [proxy.describeClass(false, {
+  methodInfix: "Numeric",
+  replaceParameterDescriptors: [
+    {
+      name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
+      replacement: exclusionFirstZeroParameterDescriptor
+    }
+  ]
+})];
+var NumericProxy = class extends (_a6 = CharacterSetCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, NUMERIC_CREATOR);
   }
 };
-NumericProxy = __decorateClass([
-  ProxyClass({
-    methodInfix: "Numeric",
-    replaceParameterDescriptors: [
-      {
-        name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
-        replacement: exclusionFirstZeroParameterDescriptor
-      }
-    ]
-  })
-], NumericProxy);
-var HexadecimalProxy = class extends CharacterSetCreatorProxy {
+_init6 = __decoratorStart(_a6);
+NumericProxy = __decorateElement(_init6, 0, "NumericProxy", _NumericProxy_decorators, NumericProxy);
+__runInitializers(_init6, 1, NumericProxy);
+var _HexadecimalProxy_decorators, _init7, _a7;
+_HexadecimalProxy_decorators = [proxy.describeClass(false, {
+  methodInfix: "Hexadecimal",
+  replaceParameterDescriptors: [
+    {
+      name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
+      replacement: exclusionAnyParameterDescriptor
+    }
+  ]
+})];
+var HexadecimalProxy = class extends (_a7 = CharacterSetCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, HEXADECIMAL_CREATOR);
   }
 };
-HexadecimalProxy = __decorateClass([
-  ProxyClass({
-    methodInfix: "Hexadecimal",
-    replaceParameterDescriptors: [
-      {
-        name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
-        replacement: exclusionAnyParameterDescriptor
-      }
-    ]
-  })
-], HexadecimalProxy);
-var AlphabeticProxy = class extends CharacterSetCreatorProxy {
+_init7 = __decoratorStart(_a7);
+HexadecimalProxy = __decorateElement(_init7, 0, "HexadecimalProxy", _HexadecimalProxy_decorators, HexadecimalProxy);
+__runInitializers(_init7, 1, HexadecimalProxy);
+var _AlphabeticProxy_decorators, _init8, _a8;
+_AlphabeticProxy_decorators = [proxy.describeClass(false, {
+  methodInfix: "Alphabetic"
+})];
+var AlphabeticProxy = class extends (_a8 = CharacterSetCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, ALPHABETIC_CREATOR);
   }
 };
-AlphabeticProxy = __decorateClass([
-  ProxyClass({
-    methodInfix: "Alphabetic"
-  })
-], AlphabeticProxy);
-var AlphanumericProxy = class extends CharacterSetCreatorProxy {
+_init8 = __decoratorStart(_a8);
+AlphabeticProxy = __decorateElement(_init8, 0, "AlphabeticProxy", _AlphabeticProxy_decorators, AlphabeticProxy);
+__runInitializers(_init8, 1, AlphabeticProxy);
+var _AlphanumericProxy_decorators, _init9, _a9;
+_AlphanumericProxy_decorators = [proxy.describeClass(false, {
+  methodInfix: "Alphanumeric",
+  replaceParameterDescriptors: [
+    {
+      name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
+      replacement: exclusionAnyParameterDescriptor
+    }
+  ]
+})];
+var AlphanumericProxy = class extends (_a9 = CharacterSetCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, ALPHANUMERIC_CREATOR);
   }
 };
-AlphanumericProxy = __decorateClass([
-  ProxyClass({
-    methodInfix: "Alphanumeric",
-    replaceParameterDescriptors: [
-      {
-        name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
-        replacement: exclusionAnyParameterDescriptor
-      }
-    ]
-  })
-], AlphanumericProxy);
+_init9 = __decoratorStart(_a9);
+AlphanumericProxy = __decorateElement(_init9, 0, "AlphanumericProxy", _AlphanumericProxy_decorators, AlphanumericProxy);
+__runInitializers(_init9, 1, AlphanumericProxy);
 
 // src/gs1/index.ts
 var gs1_exports = {};
@@ -2296,51 +2501,57 @@ __export(gs1_exports, {
 
 // src/gs1/character-set-proxy.ts
 import { AI39_CREATOR, AI64_VALIDATOR, AI82_CREATOR } from "@aidc-toolkit/gs1";
-var AI82Proxy = class extends CharacterSetCreatorProxy {
+var _AI82Proxy_decorators, _init10, _a10;
+_AI82Proxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "AI82",
+  replaceParameterDescriptors: [
+    {
+      name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
+      replacement: exclusionAllNumericParameterDescriptor
+    }
+  ]
+})];
+var AI82Proxy = class extends (_a10 = CharacterSetCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, AI82_CREATOR);
   }
 };
-AI82Proxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "AI82",
-    replaceParameterDescriptors: [
-      {
-        name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
-        replacement: exclusionAllNumericParameterDescriptor
-      }
-    ]
-  })
-], AI82Proxy);
-var AI39Proxy = class extends CharacterSetCreatorProxy {
+_init10 = __decoratorStart(_a10);
+AI82Proxy = __decorateElement(_init10, 0, "AI82Proxy", _AI82Proxy_decorators, AI82Proxy);
+__runInitializers(_init10, 1, AI82Proxy);
+var _AI39Proxy_decorators, _init11, _a11;
+_AI39Proxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "AI39",
+  replaceParameterDescriptors: [
+    {
+      name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
+      replacement: exclusionAllNumericParameterDescriptor
+    }
+  ]
+})];
+var AI39Proxy = class extends (_a11 = CharacterSetCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, AI39_CREATOR);
   }
 };
-AI39Proxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "AI39",
-    replaceParameterDescriptors: [
-      {
-        name: expandParameterDescriptor(exclusionNoneParameterDescriptor).name,
-        replacement: exclusionAllNumericParameterDescriptor
-      }
-    ]
-  })
-], AI39Proxy);
-var AI64Proxy = class extends CharacterSetValidatorProxy {
+_init11 = __decoratorStart(_a11);
+AI39Proxy = __decorateElement(_init11, 0, "AI39Proxy", _AI39Proxy_decorators, AI39Proxy);
+__runInitializers(_init11, 1, AI39Proxy);
+var _AI64Proxy_decorators, _init12, _a12;
+_AI64Proxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "AI64"
+})];
+var AI64Proxy = class extends (_a12 = CharacterSetValidatorProxy) {
   constructor(appExtension) {
     super(appExtension, AI64_VALIDATOR);
   }
 };
-AI64Proxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "AI64"
-  })
-], AI64Proxy);
+_init12 = __decoratorStart(_a12);
+AI64Proxy = __decorateElement(_init12, 0, "AI64Proxy", _AI64Proxy_decorators, AI64Proxy);
+__runInitializers(_init12, 1, AI64Proxy);
 
 // src/gs1/check-proxy.ts
 import {
@@ -2385,7 +2596,42 @@ var ai82SWithCheckCharacterPairParameterDescriptor = {
   extendsDescriptor: ai82SParameterDescriptor,
   name: "ai82SWithCheckCharacterPair"
 };
-var CheckProxy = class extends LibProxy {
+var _hasValidCheckCharacterPair_dec, _checkCharacterPair_dec, _isValidPriceOrWeightCheckDigit_dec, _priceOrWeightCheckDigit_dec, _hasValidCheckDigit_dec, _checkDigit_dec, _a13, _CheckProxy_decorators, _init13;
+_CheckProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1"
+})];
+var CheckProxy = class extends (_a13 = LibProxy, _checkDigit_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [numericSParameterDescriptor]
+})], _hasValidCheckDigit_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [numericSWithCheckDigitParameterDescriptor]
+})], _priceOrWeightCheckDigit_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [numericSFourOrFiveDigitsParameterDescriptor]
+})], _isValidPriceOrWeightCheckDigit_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: false,
+  parameterDescriptors: [{
+    ...numericSFourOrFiveDigitsParameterDescriptor,
+    isMatrix: false
+  }, checkDigitParameterDescriptor]
+})], _checkCharacterPair_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [ai82SParameterDescriptor]
+})], _hasValidCheckCharacterPair_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [ai82SWithCheckCharacterPairParameterDescriptor]
+})], _a13) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init13, 5, this);
+  }
   checkDigit(matrixSs) {
     return this.mapMatrix(matrixSs, (s) => checkDigit(s));
   }
@@ -2405,70 +2651,46 @@ var CheckProxy = class extends LibProxy {
     return this.mapMatrix(matrixSs, (s) => hasValidCheckCharacterPair(s));
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(numericSParameterDescriptor))
-], CheckProxy.prototype, "checkDigit", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(numericSWithCheckDigitParameterDescriptor))
-], CheckProxy.prototype, "hasValidCheckDigit", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(numericSFourOrFiveDigitsParameterDescriptor))
-], CheckProxy.prototype, "priceOrWeightCheckDigit", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: false
-  }),
-  __decorateParam(0, ProxyParameter({
-    ...numericSFourOrFiveDigitsParameterDescriptor,
-    isMatrix: false
-  })),
-  __decorateParam(1, ProxyParameter(checkDigitParameterDescriptor))
-], CheckProxy.prototype, "isValidPriceOrWeightCheckDigit", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(ai82SParameterDescriptor))
-], CheckProxy.prototype, "checkCharacterPair", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(ai82SWithCheckCharacterPairParameterDescriptor))
-], CheckProxy.prototype, "hasValidCheckCharacterPair", 1);
-CheckProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1"
-  })
-], CheckProxy);
+_init13 = __decoratorStart(_a13);
+__decorateElement(_init13, 1, "checkDigit", _checkDigit_dec, CheckProxy);
+__decorateElement(_init13, 1, "hasValidCheckDigit", _hasValidCheckDigit_dec, CheckProxy);
+__decorateElement(_init13, 1, "priceOrWeightCheckDigit", _priceOrWeightCheckDigit_dec, CheckProxy);
+__decorateElement(_init13, 1, "isValidPriceOrWeightCheckDigit", _isValidPriceOrWeightCheckDigit_dec, CheckProxy);
+__decorateElement(_init13, 1, "checkCharacterPair", _checkCharacterPair_dec, CheckProxy);
+__decorateElement(_init13, 1, "hasValidCheckCharacterPair", _hasValidCheckCharacterPair_dec, CheckProxy);
+CheckProxy = __decorateElement(_init13, 0, "CheckProxy", _CheckProxy_decorators, CheckProxy);
+__runInitializers(_init13, 1, CheckProxy);
 
-// src/gs1/identifier-proxy.ts
-import { isNullish as isNullish2 } from "@aidc-toolkit/core";
-import {
-  GTINCreator,
-  GTINLengths,
-  GTINValidator,
-  IdentifierValidators,
-  PrefixManager,
-  PrefixTypes,
-  PrefixValidator
-} from "@aidc-toolkit/gs1";
-import { Sequence as Sequence3 } from "@aidc-toolkit/utility";
+// src/gs1/gtin-validator-proxy.ts
+import { GTINLengths, GTINValidator, IdentifierValidators } from "@aidc-toolkit/gs1";
+
+// src/gs1/gtin-descriptor.ts
+var indicatorDigitParameterDescriptor = {
+  name: "indicatorDigit",
+  type: Types.String,
+  isMatrix: false,
+  isRequired: true
+};
+var rcnFormatParameterDescriptor = {
+  name: "rcnFormat",
+  type: Types.String,
+  isMatrix: false,
+  isRequired: true
+};
+var rcnItemReferenceParameterDescriptor = {
+  name: "rcnItemReference",
+  type: Types.Number,
+  isMatrix: false,
+  isRequired: true
+};
+var rcnPriceOrWeightParameterDescriptor = {
+  name: "rcnPriceOrWeight",
+  type: Types.Number,
+  isMatrix: true,
+  isRequired: true
+};
+
+// src/gs1/identifier-validator-proxy.ts
 var identifierParameterDescriptor = {
   name: "identifier",
   type: Types.String,
@@ -2490,18 +2712,27 @@ var IdentifierValidatorProxy = class extends StringProxy {
     return this.#validator;
   }
 };
-var NumericIdentifierValidatorProxy = class extends IdentifierValidatorProxy {
+var _validate_dec3, _a14, _NumericIdentifierValidatorProxy_decorators, _init14;
+_NumericIdentifierValidatorProxy_decorators = [proxy.describeClass(true, {
+  namespace: "GS1"
+})];
+var NumericIdentifierValidatorProxy = class extends (_a14 = IdentifierValidatorProxy, _validate_dec3 = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [validateIdentifierParameterDescriptor]
+})], _a14) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init14, 5, this);
+  }
   validate(matrixIdentifiers) {
     return this.validateString(this.validator, matrixIdentifiers);
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(validateIdentifierParameterDescriptor))
-], NumericIdentifierValidatorProxy.prototype, "validate", 1);
+_init14 = __decoratorStart(_a14);
+__decorateElement(_init14, 1, "validate", _validate_dec3, NumericIdentifierValidatorProxy);
+NumericIdentifierValidatorProxy = __decorateElement(_init14, 0, "NumericIdentifierValidatorProxy", _NumericIdentifierValidatorProxy_decorators, NumericIdentifierValidatorProxy);
+__runInitializers(_init14, 1, NumericIdentifierValidatorProxy);
 var GTINValidatorProxy = class extends NumericIdentifierValidatorProxy {
 };
 var NonGTINNumericIdentifierValidatorProxy = class extends NumericIdentifierValidatorProxy {
@@ -2510,54 +2741,70 @@ var NonSerializableNumericIdentifierValidatorProxy = class extends NonGTINNumeri
 };
 var SerializableNumericIdentifierValidatorProxy = class extends NonGTINNumericIdentifierValidatorProxy {
 };
-var NonNumericIdentifierValidatorProxy = class extends IdentifierValidatorProxy {
+var _validate_dec4, _a15, _NonNumericIdentifierValidatorProxy_decorators, _init15;
+_NonNumericIdentifierValidatorProxy_decorators = [proxy.describeClass(true, {
+  namespace: "GS1"
+})];
+var NonNumericIdentifierValidatorProxy = class extends (_a15 = IdentifierValidatorProxy, _validate_dec4 = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [validateIdentifierParameterDescriptor, exclusionAllNumericParameterDescriptor]
+})], _a15) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init15, 5, this);
+  }
   validate(matrixIdentifiers, exclusion) {
     return this.validateString(this.validator, matrixIdentifiers, {
       exclusion: exclusion ?? void 0
     });
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(validateIdentifierParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(exclusionAllNumericParameterDescriptor))
-], NonNumericIdentifierValidatorProxy.prototype, "validate", 1);
-var GTIN13ValidatorProxy = class extends GTINValidatorProxy {
+_init15 = __decoratorStart(_a15);
+__decorateElement(_init15, 1, "validate", _validate_dec4, NonNumericIdentifierValidatorProxy);
+NonNumericIdentifierValidatorProxy = __decorateElement(_init15, 0, "NonNumericIdentifierValidatorProxy", _NonNumericIdentifierValidatorProxy_decorators, NonNumericIdentifierValidatorProxy);
+__runInitializers(_init15, 1, NonNumericIdentifierValidatorProxy);
+
+// src/gs1/gtin-validator-proxy.ts
+var _GTIN13ValidatorProxy_decorators, _init16, _a16;
+_GTIN13ValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GTIN13"
+})];
+var GTIN13ValidatorProxy = class extends (_a16 = GTINValidatorProxy) {
   constructor(appExtension) {
     super(appExtension, IdentifierValidators.GTIN[GTINLengths.GTIN13]);
   }
 };
-GTIN13ValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GTIN13"
-  })
-], GTIN13ValidatorProxy);
-var GTIN12ValidatorProxy = class extends GTINValidatorProxy {
+_init16 = __decoratorStart(_a16);
+GTIN13ValidatorProxy = __decorateElement(_init16, 0, "GTIN13ValidatorProxy", _GTIN13ValidatorProxy_decorators, GTIN13ValidatorProxy);
+__runInitializers(_init16, 1, GTIN13ValidatorProxy);
+var _GTIN12ValidatorProxy_decorators, _init17, _a17;
+_GTIN12ValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GTIN12"
+})];
+var GTIN12ValidatorProxy = class extends (_a17 = GTINValidatorProxy) {
   constructor(appExtension) {
     super(appExtension, IdentifierValidators.GTIN[GTINLengths.GTIN12]);
   }
 };
-GTIN12ValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GTIN12"
-  })
-], GTIN12ValidatorProxy);
-var GTIN8ValidatorProxy = class extends GTINValidatorProxy {
+_init17 = __decoratorStart(_a17);
+GTIN12ValidatorProxy = __decorateElement(_init17, 0, "GTIN12ValidatorProxy", _GTIN12ValidatorProxy_decorators, GTIN12ValidatorProxy);
+__runInitializers(_init17, 1, GTIN12ValidatorProxy);
+var _GTIN8ValidatorProxy_decorators, _init18, _a18;
+_GTIN8ValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GTIN8"
+})];
+var GTIN8ValidatorProxy = class extends (_a18 = GTINValidatorProxy) {
   constructor(appExtension) {
     super(appExtension, IdentifierValidators.GTIN[GTINLengths.GTIN8]);
   }
 };
-GTIN8ValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GTIN8"
-  })
-], GTIN8ValidatorProxy);
+_init18 = __decoratorStart(_a18);
+GTIN8ValidatorProxy = __decorateElement(_init18, 0, "GTIN8ValidatorProxy", _GTIN8ValidatorProxy_decorators, GTIN8ValidatorProxy);
+__runInitializers(_init18, 1, GTIN8ValidatorProxy);
 var zeroSuppressibleGTIN12ParameterDescriptor = {
   extendsDescriptor: identifierParameterDescriptor,
   name: "zeroSuppressibleGTIN12"
@@ -2566,12 +2813,6 @@ var zeroSuppressedGTIN12ParameterDescriptor = {
   extendsDescriptor: identifierParameterDescriptor,
   name: "zeroSuppressedGTIN12"
 };
-var indicatorDigitParameterDescriptor = {
-  name: "indicatorDigit",
-  type: Types.String,
-  isMatrix: false,
-  isRequired: true
-};
 var convertGTINParameterDescriptor = {
   extendsDescriptor: identifierParameterDescriptor,
   name: "convertGTIN"
@@ -2594,31 +2835,49 @@ var validateGTIN14ParameterDescriptor = {
   extendsDescriptor: identifierParameterDescriptor,
   name: "validateGTIN14"
 };
-var rcnFormatParameterDescriptor = {
-  name: "rcnFormat",
-  type: Types.String,
-  isMatrix: false,
-  isRequired: true
-};
 var rcnParameterDescriptor = {
   name: "rcn",
   type: Types.String,
   isMatrix: true,
   isRequired: true
 };
-var rcnItemReferenceParameterDescriptor = {
-  name: "rcnItemReference",
-  type: Types.Number,
-  isMatrix: false,
-  isRequired: true
-};
-var rcnPriceOrWeightParameterDescriptor = {
-  name: "rcnPriceOrWeight",
+var _parseVariableMeasureRCN_dec, _validateGTIN14_dec, _validateGTIN_dec, _normalizeGTIN_dec, _convertToGTIN14_dec, _zeroExpandGTIN12_dec, _zeroSuppressGTIN12_dec, _a19, _GTINValidatorStaticProxy_decorators, _init19;
+_GTINValidatorStaticProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1"
+})];
+var GTINValidatorStaticProxy = class extends (_a19 = LibProxy, _zeroSuppressGTIN12_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [zeroSuppressibleGTIN12ParameterDescriptor]
+})], _zeroExpandGTIN12_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [zeroSuppressedGTIN12ParameterDescriptor]
+})], _convertToGTIN14_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [indicatorDigitParameterDescriptor, convertGTINParameterDescriptor]
+})], _normalizeGTIN_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [normalizeGTINParameterDescriptor]
+})], _validateGTIN_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [validateGTINParameterDescriptor, gtinLevelParameterDescriptor]
+})], _validateGTIN14_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [validateGTIN14ParameterDescriptor]
+})], _parseVariableMeasureRCN_dec = [proxy.describeMethod({
   type: Types.Number,
   isMatrix: true,
-  isRequired: true
-};
-var GTINValidatorStaticProxy = class extends LibProxy {
+  parameterDescriptors: [rcnFormatParameterDescriptor, rcnParameterDescriptor]
+})], _a19) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init19, 5, this);
+  }
   zeroSuppressGTIN12(matrixGTIN12s) {
     return this.mapMatrix(matrixGTIN12s, (gtin12) => GTINValidator.zeroSuppress(gtin12));
   }
@@ -2649,184 +2908,164 @@ var GTINValidatorStaticProxy = class extends LibProxy {
     });
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(zeroSuppressibleGTIN12ParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "zeroSuppressGTIN12", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(zeroSuppressedGTIN12ParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "zeroExpandGTIN12", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(indicatorDigitParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(convertGTINParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "convertToGTIN14", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(normalizeGTINParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "normalizeGTIN", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(validateGTINParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(gtinLevelParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "validateGTIN", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(validateGTIN14ParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "validateGTIN14", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.Number,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(rcnFormatParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(rcnParameterDescriptor))
-], GTINValidatorStaticProxy.prototype, "parseVariableMeasureRCN", 1);
-GTINValidatorStaticProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1"
-  })
-], GTINValidatorStaticProxy);
-var GLNValidatorProxy = class extends NonSerializableNumericIdentifierValidatorProxy {
+_init19 = __decoratorStart(_a19);
+__decorateElement(_init19, 1, "zeroSuppressGTIN12", _zeroSuppressGTIN12_dec, GTINValidatorStaticProxy);
+__decorateElement(_init19, 1, "zeroExpandGTIN12", _zeroExpandGTIN12_dec, GTINValidatorStaticProxy);
+__decorateElement(_init19, 1, "convertToGTIN14", _convertToGTIN14_dec, GTINValidatorStaticProxy);
+__decorateElement(_init19, 1, "normalizeGTIN", _normalizeGTIN_dec, GTINValidatorStaticProxy);
+__decorateElement(_init19, 1, "validateGTIN", _validateGTIN_dec, GTINValidatorStaticProxy);
+__decorateElement(_init19, 1, "validateGTIN14", _validateGTIN14_dec, GTINValidatorStaticProxy);
+__decorateElement(_init19, 1, "parseVariableMeasureRCN", _parseVariableMeasureRCN_dec, GTINValidatorStaticProxy);
+GTINValidatorStaticProxy = __decorateElement(_init19, 0, "GTINValidatorStaticProxy", _GTINValidatorStaticProxy_decorators, GTINValidatorStaticProxy);
+__runInitializers(_init19, 1, GTINValidatorStaticProxy);
+
+// src/gs1/non-gtin-validator-proxy.ts
+import { IdentifierValidators as IdentifierValidators2 } from "@aidc-toolkit/gs1";
+var _GLNValidatorProxy_decorators, _init20, _a20;
+_GLNValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GLN"
+})];
+var GLNValidatorProxy = class extends (_a20 = NonSerializableNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GLN);
-  }
-};
-GLNValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GLN"
-  })
-], GLNValidatorProxy);
-var SSCCValidatorProxy = class extends NonSerializableNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GLN);
+  }
+};
+_init20 = __decoratorStart(_a20);
+GLNValidatorProxy = __decorateElement(_init20, 0, "GLNValidatorProxy", _GLNValidatorProxy_decorators, GLNValidatorProxy);
+__runInitializers(_init20, 1, GLNValidatorProxy);
+var _SSCCValidatorProxy_decorators, _init21, _a21;
+_SSCCValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "SSCC"
+})];
+var SSCCValidatorProxy = class extends (_a21 = NonSerializableNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.SSCC);
-  }
-};
-SSCCValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "SSCC"
-  })
-], SSCCValidatorProxy);
-var GRAIValidatorProxy = class extends SerializableNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.SSCC);
+  }
+};
+_init21 = __decoratorStart(_a21);
+SSCCValidatorProxy = __decorateElement(_init21, 0, "SSCCValidatorProxy", _SSCCValidatorProxy_decorators, SSCCValidatorProxy);
+__runInitializers(_init21, 1, SSCCValidatorProxy);
+var _GRAIValidatorProxy_decorators, _init22, _a22;
+_GRAIValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GRAI"
+})];
+var GRAIValidatorProxy = class extends (_a22 = SerializableNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GRAI);
-  }
-};
-GRAIValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GRAI"
-  })
-], GRAIValidatorProxy);
-var GIAIValidatorProxy = class extends NonNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GRAI);
+  }
+};
+_init22 = __decoratorStart(_a22);
+GRAIValidatorProxy = __decorateElement(_init22, 0, "GRAIValidatorProxy", _GRAIValidatorProxy_decorators, GRAIValidatorProxy);
+__runInitializers(_init22, 1, GRAIValidatorProxy);
+var _GIAIValidatorProxy_decorators, _init23, _a23;
+_GIAIValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GIAI"
+})];
+var GIAIValidatorProxy = class extends (_a23 = NonNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GIAI);
-  }
-};
-GIAIValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GIAI"
-  })
-], GIAIValidatorProxy);
-var GSRNValidatorProxy = class extends NonSerializableNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GIAI);
+  }
+};
+_init23 = __decoratorStart(_a23);
+GIAIValidatorProxy = __decorateElement(_init23, 0, "GIAIValidatorProxy", _GIAIValidatorProxy_decorators, GIAIValidatorProxy);
+__runInitializers(_init23, 1, GIAIValidatorProxy);
+var _GSRNValidatorProxy_decorators, _init24, _a24;
+_GSRNValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GSRN"
+})];
+var GSRNValidatorProxy = class extends (_a24 = NonSerializableNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GSRN);
-  }
-};
-GSRNValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GSRN"
-  })
-], GSRNValidatorProxy);
-var GDTIValidatorProxy = class extends SerializableNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GSRN);
+  }
+};
+_init24 = __decoratorStart(_a24);
+GSRNValidatorProxy = __decorateElement(_init24, 0, "GSRNValidatorProxy", _GSRNValidatorProxy_decorators, GSRNValidatorProxy);
+__runInitializers(_init24, 1, GSRNValidatorProxy);
+var _GDTIValidatorProxy_decorators, _init25, _a25;
+_GDTIValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GDTI"
+})];
+var GDTIValidatorProxy = class extends (_a25 = SerializableNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GDTI);
-  }
-};
-GDTIValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GDTI"
-  })
-], GDTIValidatorProxy);
-var GINCValidatorProxy = class extends NonNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GDTI);
+  }
+};
+_init25 = __decoratorStart(_a25);
+GDTIValidatorProxy = __decorateElement(_init25, 0, "GDTIValidatorProxy", _GDTIValidatorProxy_decorators, GDTIValidatorProxy);
+__runInitializers(_init25, 1, GDTIValidatorProxy);
+var _GINCValidatorProxy_decorators, _init26, _a26;
+_GINCValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GINC"
+})];
+var GINCValidatorProxy = class extends (_a26 = NonNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GINC);
-  }
-};
-GINCValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GINC"
-  })
-], GINCValidatorProxy);
-var GSINValidatorProxy = class extends NonSerializableNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GINC);
+  }
+};
+_init26 = __decoratorStart(_a26);
+GINCValidatorProxy = __decorateElement(_init26, 0, "GINCValidatorProxy", _GINCValidatorProxy_decorators, GINCValidatorProxy);
+__runInitializers(_init26, 1, GINCValidatorProxy);
+var _GSINValidatorProxy_decorators, _init27, _a27;
+_GSINValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GSIN"
+})];
+var GSINValidatorProxy = class extends (_a27 = NonSerializableNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GSIN);
-  }
-};
-GSINValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GSIN"
-  })
-], GSINValidatorProxy);
-var GCNValidatorProxy = class extends SerializableNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GSIN);
+  }
+};
+_init27 = __decoratorStart(_a27);
+GSINValidatorProxy = __decorateElement(_init27, 0, "GSINValidatorProxy", _GSINValidatorProxy_decorators, GSINValidatorProxy);
+__runInitializers(_init27, 1, GSINValidatorProxy);
+var _GCNValidatorProxy_decorators, _init28, _a28;
+_GCNValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GCN"
+})];
+var GCNValidatorProxy = class extends (_a28 = SerializableNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GCN);
-  }
-};
-GCNValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GCN"
-  })
-], GCNValidatorProxy);
-var CPIDValidatorProxy = class extends NonNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.GCN);
+  }
+};
+_init28 = __decoratorStart(_a28);
+GCNValidatorProxy = __decorateElement(_init28, 0, "GCNValidatorProxy", _GCNValidatorProxy_decorators, GCNValidatorProxy);
+__runInitializers(_init28, 1, GCNValidatorProxy);
+var _CPIDValidatorProxy_decorators, _init29, _a29;
+_CPIDValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "CPID"
+})];
+var CPIDValidatorProxy = class extends (_a29 = NonNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.CPID);
-  }
-};
-CPIDValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "CPID"
-  })
-], CPIDValidatorProxy);
-var GMNValidatorProxy = class extends NonNumericIdentifierValidatorProxy {
+    super(appExtension, IdentifierValidators2.CPID);
+  }
+};
+_init29 = __decoratorStart(_a29);
+CPIDValidatorProxy = __decorateElement(_init29, 0, "CPIDValidatorProxy", _CPIDValidatorProxy_decorators, CPIDValidatorProxy);
+__runInitializers(_init29, 1, CPIDValidatorProxy);
+var _GMNValidatorProxy_decorators, _init30, _a30;
+_GMNValidatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GMN"
+})];
+var GMNValidatorProxy = class extends (_a30 = NonNumericIdentifierValidatorProxy) {
   constructor(appExtension) {
-    super(appExtension, IdentifierValidators.GMN);
+    super(appExtension, IdentifierValidators2.GMN);
   }
 };
-GMNValidatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GMN"
-  })
-], GMNValidatorProxy);
+_init30 = __decoratorStart(_a30);
+GMNValidatorProxy = __decorateElement(_init30, 0, "GMNValidatorProxy", _GMNValidatorProxy_decorators, GMNValidatorProxy);
+__runInitializers(_init30, 1, GMNValidatorProxy);
+
+// src/gs1/prefix-manager-proxy.ts
 var prefixParameterDescriptor = {
   name: "prefix",
   type: Types.String,
@@ -2845,6 +3084,41 @@ var tweakFactorParameterDescriptor = {
   isMatrix: false,
   isRequired: false
 };
+var _definePrefix_dec, _a31, _PrefixManagerProxy_decorators, _init31;
+_PrefixManagerProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1"
+})];
+var PrefixManagerProxy = class extends (_a31 = LibProxy, _definePrefix_dec = [proxy.describeMethod({
+  type: Types.Any,
+  isMatrix: true,
+  parameterDescriptors: [prefixParameterDescriptor, prefixTypeParameterDescriptor, tweakFactorParameterDescriptor]
+})], _a31) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init31, 5, this);
+  }
+  definePrefix(prefix, prefixType, tweakFactor) {
+    return [[prefix, prefixType, tweakFactor]];
+  }
+};
+_init31 = __decoratorStart(_a31);
+__decorateElement(_init31, 1, "definePrefix", _definePrefix_dec, PrefixManagerProxy);
+PrefixManagerProxy = __decorateElement(_init31, 0, "PrefixManagerProxy", _PrefixManagerProxy_decorators, PrefixManagerProxy);
+__runInitializers(_init31, 1, PrefixManagerProxy);
+
+// src/gs1/gtin-creator-proxy.ts
+import { GTINCreator } from "@aidc-toolkit/gs1";
+
+// src/gs1/identifier-creator-proxy.ts
+import { isNullish as isNullish2 } from "@aidc-toolkit/core";
+import {
+  PrefixManager,
+  PrefixTypes,
+  PrefixValidator
+} from "@aidc-toolkit/gs1";
+import { Sequence as Sequence3 } from "@aidc-toolkit/utility";
+
+// src/gs1/prefix-definition-descriptor.ts
 var prefixDefinitionParameterDescriptor = {
   name: "prefixDefinition",
   type: Types.Any,
@@ -2859,25 +3133,8 @@ var prefixDefinitionAnyParameterDescriptor = {
   extendsDescriptor: prefixDefinitionParameterDescriptor,
   name: "prefixDefinitionAny"
 };
-var PrefixManagerProxy = class extends LibProxy {
-  definePrefix(prefix, prefixType, tweakFactor) {
-    return [[prefix, prefixType, tweakFactor]];
-  }
-};
-__decorateClass([
-  ProxyMethod({
-    type: Types.Any,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(prefixParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(prefixTypeParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(tweakFactorParameterDescriptor))
-], PrefixManagerProxy.prototype, "definePrefix", 1);
-PrefixManagerProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1"
-  })
-], PrefixManagerProxy);
+
+// src/gs1/identifier-creator-proxy.ts
 var IdentifierCreatorProxy = class _IdentifierCreatorProxy extends LibProxy {
   static #PREFIX_TYPES = [PrefixTypes.GS1CompanyPrefix, PrefixTypes.UPCCompanyPrefix, PrefixTypes.GS18Prefix];
   #getCreator;
@@ -2934,7 +3191,28 @@ var sparseParameterDescriptor = {
   isMatrix: false,
   isRequired: false
 };
-var NumericIdentifierCreatorProxy = class extends IdentifierCreatorProxy {
+var _createAll_dec, _createSequence_dec2, _create_dec2, _a32, _NumericIdentifierCreatorProxy_decorators, _init32;
+_NumericIdentifierCreatorProxy_decorators = [proxy.describeClass(true, {
+  namespace: "GS1"
+})];
+var NumericIdentifierCreatorProxy = class extends (_a32 = IdentifierCreatorProxy, _create_dec2 = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, valueParameterDescriptor, sparseParameterDescriptor]
+})], _createSequence_dec2 = [proxy.describeMethod({
+  infixBefore: "Sequence",
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, startValueParameterDescriptor, countParameterDescriptor, sparseParameterDescriptor]
+})], _createAll_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor]
+})], _a32) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init32, 5, this);
+  }
   create(prefixDefinition, matrixValues, sparse) {
     const creator = this.getCreator(prefixDefinition);
     const sparseOrUndefined = sparse ?? void 0;
@@ -2950,33 +3228,12 @@ var NumericIdentifierCreatorProxy = class extends IdentifierCreatorProxy {
     return LibProxy.matrixResult(creator.createAll());
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(valueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(sparseParameterDescriptor))
-], NumericIdentifierCreatorProxy.prototype, "create", 1);
-__decorateClass([
-  ProxyMethod({
-    infixBefore: "Sequence",
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(startValueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(countParameterDescriptor)),
-  __decorateParam(3, ProxyParameter(sparseParameterDescriptor))
-], NumericIdentifierCreatorProxy.prototype, "createSequence", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor))
-], NumericIdentifierCreatorProxy.prototype, "createAll", 1);
+_init32 = __decoratorStart(_a32);
+__decorateElement(_init32, 1, "create", _create_dec2, NumericIdentifierCreatorProxy);
+__decorateElement(_init32, 1, "createSequence", _createSequence_dec2, NumericIdentifierCreatorProxy);
+__decorateElement(_init32, 1, "createAll", _createAll_dec, NumericIdentifierCreatorProxy);
+NumericIdentifierCreatorProxy = __decorateElement(_init32, 0, "NumericIdentifierCreatorProxy", _NumericIdentifierCreatorProxy_decorators, NumericIdentifierCreatorProxy);
+__runInitializers(_init32, 1, NumericIdentifierCreatorProxy);
 var NonGTINNumericIdentifierCreatorProxy = class extends NumericIdentifierCreatorProxy {
 };
 var NonSerializableNumericIdentifierCreatorProxy = class extends NonGTINNumericIdentifierCreatorProxy {
@@ -2996,7 +3253,23 @@ var serialComponentParameterDescriptor = {
   isMatrix: true,
   isRequired: true
 };
-var SerializableNumericIdentifierCreatorProxy = class extends NonGTINNumericIdentifierCreatorProxy {
+var _concatenate_dec, _createSerialized_dec, _a33, _SerializableNumericIdentifierCreatorProxy_decorators, _init33;
+_SerializableNumericIdentifierCreatorProxy_decorators = [proxy.describeClass(true, {
+  namespace: "GS1"
+})];
+var SerializableNumericIdentifierCreatorProxy = class extends (_a33 = NonGTINNumericIdentifierCreatorProxy, _createSerialized_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, singleValueParameterDescriptor, serialComponentParameterDescriptor, sparseParameterDescriptor]
+})], _concatenate_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [baseIdentifierParameterDescriptor, serialComponentParameterDescriptor]
+})], _a33) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init33, 5, this);
+  }
   createSerialized(prefixDefinition, value, matrixSerialComponents, sparse) {
     const creator = this.getCreator(prefixDefinition);
     const sparseOrUndefined = sparse ?? void 0;
@@ -3007,47 +3280,66 @@ var SerializableNumericIdentifierCreatorProxy = class extends NonGTINNumericIden
     return this.mapMatrix(matrixSerialComponents, (serialComponent) => creator.concatenate(baseIdentifier, serialComponent));
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(singleValueParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(serialComponentParameterDescriptor)),
-  __decorateParam(3, ProxyParameter(sparseParameterDescriptor))
-], SerializableNumericIdentifierCreatorProxy.prototype, "createSerialized", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(baseIdentifierParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(serialComponentParameterDescriptor))
-], SerializableNumericIdentifierCreatorProxy.prototype, "concatenate", 1);
+_init33 = __decoratorStart(_a33);
+__decorateElement(_init33, 1, "createSerialized", _createSerialized_dec, SerializableNumericIdentifierCreatorProxy);
+__decorateElement(_init33, 1, "concatenate", _concatenate_dec, SerializableNumericIdentifierCreatorProxy);
+SerializableNumericIdentifierCreatorProxy = __decorateElement(_init33, 0, "SerializableNumericIdentifierCreatorProxy", _SerializableNumericIdentifierCreatorProxy_decorators, SerializableNumericIdentifierCreatorProxy);
+__runInitializers(_init33, 1, SerializableNumericIdentifierCreatorProxy);
 var referenceParameterDescriptor = {
   name: "reference",
   type: Types.String,
   isMatrix: true,
   isRequired: true
 };
-var NonNumericIdentifierCreatorProxy = class extends IdentifierCreatorProxy {
+var _create_dec3, _a34, _NonNumericIdentifierCreatorProxy_decorators, _init34;
+_NonNumericIdentifierCreatorProxy_decorators = [proxy.describeClass(true, {
+  namespace: "GS1"
+})];
+var NonNumericIdentifierCreatorProxy = class extends (_a34 = IdentifierCreatorProxy, _create_dec3 = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  parameterDescriptors: [prefixDefinitionGS1UPCParameterDescriptor, referenceParameterDescriptor]
+})], _a34) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init34, 5, this);
+  }
   create(prefixDefinition, matrixReferences) {
     const creator = this.getCreator(prefixDefinition);
     return this.mapMatrix(matrixReferences, (reference) => creator.create(reference));
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true
-  }),
-  __decorateParam(0, ProxyParameter(prefixDefinitionGS1UPCParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(referenceParameterDescriptor))
-], NonNumericIdentifierCreatorProxy.prototype, "create", 1);
-var GTINCreatorProxy = class extends NumericIdentifierCreatorProxy {
+_init34 = __decoratorStart(_a34);
+__decorateElement(_init34, 1, "create", _create_dec3, NonNumericIdentifierCreatorProxy);
+NonNumericIdentifierCreatorProxy = __decorateElement(_init34, 0, "NonNumericIdentifierCreatorProxy", _NonNumericIdentifierCreatorProxy_decorators, NonNumericIdentifierCreatorProxy);
+__runInitializers(_init34, 1, NonNumericIdentifierCreatorProxy);
+
+// src/gs1/gtin-creator-proxy.ts
+var _createVariableMeasureRCN_dec, _createGTIN14_dec, _a35, _GTINCreatorProxy_decorators, _init35;
+_GTINCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GTIN",
+  replaceParameterDescriptors: [
+    {
+      name: expandParameterDescriptor(prefixDefinitionGS1UPCParameterDescriptor).name,
+      replacement: prefixDefinitionAnyParameterDescriptor
+    }
+  ]
+})];
+var GTINCreatorProxy = class extends (_a35 = NumericIdentifierCreatorProxy, _createGTIN14_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  ignoreInfix: true,
+  parameterDescriptors: [indicatorDigitParameterDescriptor, prefixDefinitionAnyParameterDescriptor, valueParameterDescriptor, sparseParameterDescriptor]
+})], _createVariableMeasureRCN_dec = [proxy.describeMethod({
+  type: Types.String,
+  isMatrix: true,
+  ignoreInfix: true,
+  parameterDescriptors: [rcnFormatParameterDescriptor, rcnItemReferenceParameterDescriptor, rcnPriceOrWeightParameterDescriptor]
+})], _a35) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.gtinCreator);
+    __runInitializers(_init35, 5, this);
   }
   createGTIN14(indicatorDigit, prefixDefinition, matrixValues, sparse) {
     const creator = this.getCreator(prefixDefinition);
@@ -3058,160 +3350,156 @@ var GTINCreatorProxy = class extends NumericIdentifierCreatorProxy {
     return this.mapMatrix(matrixPricesOrWeights, (priceOrWeight) => GTINCreator.createVariableMeasureRCN(format, itemReference, priceOrWeight));
   }
 };
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true,
-    ignoreInfix: true
-  }),
-  __decorateParam(0, ProxyParameter(indicatorDigitParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(prefixDefinitionAnyParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(valueParameterDescriptor)),
-  __decorateParam(3, ProxyParameter(sparseParameterDescriptor))
-], GTINCreatorProxy.prototype, "createGTIN14", 1);
-__decorateClass([
-  ProxyMethod({
-    type: Types.String,
-    isMatrix: true,
-    ignoreInfix: true
-  }),
-  __decorateParam(0, ProxyParameter(rcnFormatParameterDescriptor)),
-  __decorateParam(1, ProxyParameter(rcnItemReferenceParameterDescriptor)),
-  __decorateParam(2, ProxyParameter(rcnPriceOrWeightParameterDescriptor))
-], GTINCreatorProxy.prototype, "createVariableMeasureRCN", 1);
-GTINCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GTIN",
-    replaceParameterDescriptors: [
-      {
-        name: expandParameterDescriptor(prefixDefinitionGS1UPCParameterDescriptor).name,
-        replacement: prefixDefinitionAnyParameterDescriptor
-      }
-    ]
-  })
-], GTINCreatorProxy);
-var GLNCreatorProxy = class extends NonSerializableNumericIdentifierCreatorProxy {
+_init35 = __decoratorStart(_a35);
+__decorateElement(_init35, 1, "createGTIN14", _createGTIN14_dec, GTINCreatorProxy);
+__decorateElement(_init35, 1, "createVariableMeasureRCN", _createVariableMeasureRCN_dec, GTINCreatorProxy);
+GTINCreatorProxy = __decorateElement(_init35, 0, "GTINCreatorProxy", _GTINCreatorProxy_decorators, GTINCreatorProxy);
+__runInitializers(_init35, 1, GTINCreatorProxy);
+
+// src/gs1/non-gtin-creator-proxy.ts
+var _GLNCreatorProxy_decorators, _init36, _a36;
+_GLNCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GLN"
+})];
+var GLNCreatorProxy = class extends (_a36 = NonSerializableNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.glnCreator);
   }
 };
-GLNCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GLN"
-  })
-], GLNCreatorProxy);
-var SSCCCreatorProxy = class extends NonSerializableNumericIdentifierCreatorProxy {
+_init36 = __decoratorStart(_a36);
+GLNCreatorProxy = __decorateElement(_init36, 0, "GLNCreatorProxy", _GLNCreatorProxy_decorators, GLNCreatorProxy);
+__runInitializers(_init36, 1, GLNCreatorProxy);
+var _SSCCCreatorProxy_decorators, _init37, _a37;
+_SSCCCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "SSCC"
+})];
+var SSCCCreatorProxy = class extends (_a37 = NonSerializableNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.ssccCreator);
   }
 };
-SSCCCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "SSCC"
-  })
-], SSCCCreatorProxy);
-var GRAICreatorProxy = class extends SerializableNumericIdentifierCreatorProxy {
+_init37 = __decoratorStart(_a37);
+SSCCCreatorProxy = __decorateElement(_init37, 0, "SSCCCreatorProxy", _SSCCCreatorProxy_decorators, SSCCCreatorProxy);
+__runInitializers(_init37, 1, SSCCCreatorProxy);
+var _GRAICreatorProxy_decorators, _init38, _a38;
+_GRAICreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GRAI"
+})];
+var GRAICreatorProxy = class extends (_a38 = SerializableNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.graiCreator);
   }
 };
-GRAICreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GRAI"
-  })
-], GRAICreatorProxy);
-var GIAICreatorProxy = class extends NonNumericIdentifierCreatorProxy {
+_init38 = __decoratorStart(_a38);
+GRAICreatorProxy = __decorateElement(_init38, 0, "GRAICreatorProxy", _GRAICreatorProxy_decorators, GRAICreatorProxy);
+__runInitializers(_init38, 1, GRAICreatorProxy);
+var _GIAICreatorProxy_decorators, _init39, _a39;
+_GIAICreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GIAI"
+})];
+var GIAICreatorProxy = class extends (_a39 = NonNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.giaiCreator);
   }
 };
-GIAICreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GIAI"
-  })
-], GIAICreatorProxy);
-var GSRNCreatorProxy = class extends NonSerializableNumericIdentifierCreatorProxy {
+_init39 = __decoratorStart(_a39);
+GIAICreatorProxy = __decorateElement(_init39, 0, "GIAICreatorProxy", _GIAICreatorProxy_decorators, GIAICreatorProxy);
+__runInitializers(_init39, 1, GIAICreatorProxy);
+var _GSRNCreatorProxy_decorators, _init40, _a40;
+_GSRNCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GSRN"
+})];
+var GSRNCreatorProxy = class extends (_a40 = NonSerializableNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.gsrnCreator);
   }
 };
-GSRNCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GSRN"
-  })
-], GSRNCreatorProxy);
-var GDTICreatorProxy = class extends SerializableNumericIdentifierCreatorProxy {
+_init40 = __decoratorStart(_a40);
+GSRNCreatorProxy = __decorateElement(_init40, 0, "GSRNCreatorProxy", _GSRNCreatorProxy_decorators, GSRNCreatorProxy);
+__runInitializers(_init40, 1, GSRNCreatorProxy);
+var _GDTICreatorProxy_decorators, _init41, _a41;
+_GDTICreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GDTI"
+})];
+var GDTICreatorProxy = class extends (_a41 = SerializableNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.gdtiCreator);
   }
 };
-GDTICreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GDTI"
-  })
-], GDTICreatorProxy);
-var GINCCreatorProxy = class extends NonNumericIdentifierCreatorProxy {
+_init41 = __decoratorStart(_a41);
+GDTICreatorProxy = __decorateElement(_init41, 0, "GDTICreatorProxy", _GDTICreatorProxy_decorators, GDTICreatorProxy);
+__runInitializers(_init41, 1, GDTICreatorProxy);
+var _GINCCreatorProxy_decorators, _init42, _a42;
+_GINCCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GINC"
+})];
+var GINCCreatorProxy = class extends (_a42 = NonNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.gincCreator);
   }
 };
-GINCCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GINC"
-  })
-], GINCCreatorProxy);
-var GSINCreatorProxy = class extends NonSerializableNumericIdentifierCreatorProxy {
+_init42 = __decoratorStart(_a42);
+GINCCreatorProxy = __decorateElement(_init42, 0, "GINCCreatorProxy", _GINCCreatorProxy_decorators, GINCCreatorProxy);
+__runInitializers(_init42, 1, GINCCreatorProxy);
+var _GSINCreatorProxy_decorators, _init43, _a43;
+_GSINCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GSIN"
+})];
+var GSINCreatorProxy = class extends (_a43 = NonSerializableNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.gsinCreator);
   }
 };
-GSINCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GSIN"
-  })
-], GSINCreatorProxy);
-var GCNCreatorProxy = class extends SerializableNumericIdentifierCreatorProxy {
+_init43 = __decoratorStart(_a43);
+GSINCreatorProxy = __decorateElement(_init43, 0, "GSINCreatorProxy", _GSINCreatorProxy_decorators, GSINCreatorProxy);
+__runInitializers(_init43, 1, GSINCreatorProxy);
+var _GCNCreatorProxy_decorators, _init44, _a44;
+_GCNCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GCN"
+})];
+var GCNCreatorProxy = class extends (_a44 = SerializableNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.gcnCreator);
   }
 };
-GCNCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GCN"
-  })
-], GCNCreatorProxy);
-var CPIDCreatorProxy = class extends NonNumericIdentifierCreatorProxy {
+_init44 = __decoratorStart(_a44);
+GCNCreatorProxy = __decorateElement(_init44, 0, "GCNCreatorProxy", _GCNCreatorProxy_decorators, GCNCreatorProxy);
+__runInitializers(_init44, 1, GCNCreatorProxy);
+var _CPIDCreatorProxy_decorators, _init45, _a45;
+_CPIDCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "CPID"
+})];
+var CPIDCreatorProxy = class extends (_a45 = NonNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.cpidCreator);
   }
 };
-CPIDCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "CPID"
-  })
-], CPIDCreatorProxy);
-var GMNCreatorProxy = class extends NonNumericIdentifierCreatorProxy {
+_init45 = __decoratorStart(_a45);
+CPIDCreatorProxy = __decorateElement(_init45, 0, "CPIDCreatorProxy", _CPIDCreatorProxy_decorators, CPIDCreatorProxy);
+__runInitializers(_init45, 1, CPIDCreatorProxy);
+var _GMNCreatorProxy_decorators, _init46, _a46;
+_GMNCreatorProxy_decorators = [proxy.describeClass(false, {
+  namespace: "GS1",
+  methodInfix: "GMN"
+})];
+var GMNCreatorProxy = class extends (_a46 = NonNumericIdentifierCreatorProxy) {
   constructor(appExtension) {
     super(appExtension, (prefixManager) => prefixManager.gmnCreator);
   }
 };
-GMNCreatorProxy = __decorateClass([
-  ProxyClass({
-    namespace: "GS1",
-    methodInfix: "GMN"
-  })
-], GMNCreatorProxy);
+_init46 = __decoratorStart(_a46);
+GMNCreatorProxy = __decorateElement(_init46, 0, "GMNCreatorProxy", _GMNCreatorProxy_decorators, GMNCreatorProxy);
+__runInitializers(_init46, 1, GMNCreatorProxy);
 
 // src/generator/generator.ts
 import { I18nEnvironments } from "@aidc-toolkit/core";
@@ -3239,13 +3527,6 @@ var Generator = class _Generator {
    * Map of function localizations maps by namespace function name.
    */
   #functionLocalizationsMapsMap = /* @__PURE__ */ new Map();
-  /**
-   * Map of parameter localizations maps by namespace function parameter name.
-   */
-  #parameterLocalizationsMapsMap = /* @__PURE__ */ new Map();
-  /**
-   *
-   */
   /**
    * Constructor.
    *
@@ -3271,16 +3552,16 @@ var Generator = class _Generator {
   /**
    * Get function localization.
    *
-   * @param namespaceFunctionName
-   * Namespace function name.
-   *
    * @param locale
    * Locale.
    *
+   * @param namespaceFunctionName
+   * Namespace function name.
+   *
    * @returns
    * Function localization.
    */
-  getFunctionLocalization(namespaceFunctionName, locale) {
+  getFunctionLocalization(locale, namespaceFunctionName) {
     const functionLocalization = this.#functionLocalizationsMapsMap.get(namespaceFunctionName)?.get(locale);
     if (functionLocalization === void 0) {
       throw new Error(`${locale} localization for function ${namespaceFunctionName} not found`);
@@ -3290,52 +3571,56 @@ var Generator = class _Generator {
   /**
    * Get parameter localization.
    *
+   * @param locale
+   * Locale.
+   *
    * @param namespaceFunctionName
    * Namespace function name.
    *
    * @param parameterName
    * Parameter name.
    *
-   * @param locale
-   * Locale.
-   *
    * @returns
-   * Function localization.
+   * Parameter localization.
    */
-  getParameterLocalization(namespaceFunctionName, parameterName, locale) {
-    const parameterLocalization = this.#parameterLocalizationsMapsMap.get(`${namespaceFunctionName}.${parameterName}`)?.get(locale);
+  getParameterLocalization(locale, namespaceFunctionName, parameterName) {
+    const parameterLocalization = this.getFunctionLocalization(locale, namespaceFunctionName).parametersMap.get(parameterName);
     if (parameterLocalization === void 0) {
       throw new Error(`${locale} localization for function ${namespaceFunctionName} parameter ${parameterName} not found`);
     }
     return parameterLocalization;
   }
   /**
-   * Generate localizations map.
+   * Generate a localization.
    *
    * @template TLocalization
    * Localization type.
    *
+   * @param locale
+   * Locale.
+   *
    * @param localizedKeyPrefix
    * Localized key prefix.
    *
+   * @param namespacePrefix
+   * Namespace prefix to be appended to name.
+   *
    * @param localizationCallback
    * Callback to finalize localization.
    *
    * @returns
-   * Localization map.
+   * Localization.
    */
-  #generateLocalizationsMap(localizedKeyPrefix, localizationCallback) {
-    return new Map(this.#locales.map((locale) => {
-      const lngOption = {
-        lng: locale
-      };
-      return [locale, localizationCallback(locale, {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
-        name: i18nextAppExtension.t(`${localizedKeyPrefix}name`, lngOption),
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
-        description: i18nextAppExtension.t(`${localizedKeyPrefix}description`, lngOption)
-      })];
-    }));
+  #generateLocalization(locale, localizedKeyPrefix, namespacePrefix, localizationCallback) {
+    const lngOption = {
+      lng: locale
+    };
+    return localizationCallback(locale, {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
+      name: `${namespacePrefix}${i18nextAppExtension.t(`${localizedKeyPrefix}name`, lngOption)}`,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Localized key exists.
+      description: i18nextAppExtension.t(`${localizedKeyPrefix}description`, lngOption)
+    });
   }
   /**
    * Generate by processing individual imports.
@@ -3345,64 +3630,27 @@ var Generator = class _Generator {
     await i18nAppExtensionInit(I18nEnvironments.CLI);
     this.initialize();
     try {
-      for (const classDescriptor of getClassDescriptorsMap().values()) {
+      for (const [_namespaceClassName, classDescriptor] of proxy.classDescriptorsMap.entries()) {
         const namespace = classDescriptor.namespace;
         const namespacePrefix = namespace === void 0 ? "" : `${namespace}.`;
-        const className = classDescriptor.name;
-        const methodInfix = classDescriptor.methodInfix;
-        const namespaceClassName = `${namespacePrefix}${className}`;
-        const classNameMatch = /^([A-Z]+[0-9]*|[A-Z][^A-Z.]*)([A-Z][^.]*|)\.?([A-Z].*|)$/.exec(namespaceClassName);
-        if (classNameMatch === null) {
-          throw new Error(`${namespaceClassName} is not a valid namespace-qualified class name`);
-        }
-        const proxyObjectDescriptor = {
-          namespace,
-          className,
-          namespaceClassName,
-          classDescriptor,
-          objectName: `${classNameMatch[1].toLowerCase()}${classNameMatch[2]}${classNameMatch[3]}`
-        };
-        this.createProxyObject(proxyObjectDescriptor);
+        const namespacePath = namespace === void 0 ? "" : `${namespace}/`;
+        this.createProxyObject(classDescriptor);
         for (const methodDescriptor of classDescriptor.methodDescriptors) {
-          const methodName = methodDescriptor.name;
-          const infixBefore = methodDescriptor.infixBefore;
-          let functionName;
-          if (methodInfix === void 0 || methodDescriptor.ignoreInfix === true) {
-            functionName = methodName;
-          } else if (infixBefore === void 0) {
-            functionName = `${methodName}${methodInfix}`;
-          } else {
-            const insertIndex = methodName.indexOf(infixBefore);
-            if (insertIndex === -1) {
-              throw new Error(`Cannot find "${infixBefore}" in method ${methodName}`);
-            }
-            functionName = `${methodName.substring(0, insertIndex)}${methodInfix}${methodName.substring(insertIndex)}`;
-          }
-          const namespaceFunctionName = `${namespacePrefix}${functionName}`;
-          const functionLocalizationsMap = this.#generateLocalizationsMap(`Functions.${namespaceFunctionName}.`, (locale, localization) => ({
-            ...localization,
-            documentationURL: `${_Generator.#DOCUMENTATION_BASE_URL}${locale === this.defaultLocale ? "" : `${locale}/`}${_Generator.#DOCUMENTATION_PATH}${namespace === void 0 ? "" : `${namespace}/`}${localization.name}.html`
-          }));
+          const namespaceFunctionName = methodDescriptor.namespaceFunctionName;
+          const functionLocalizationsMap = new Map(this.#locales.map(
+            (locale) => [locale, this.#generateLocalization(locale, `Functions.${namespaceFunctionName}.`, namespacePrefix, (locale2, localization) => ({
+              ...localization,
+              documentationURL: `${_Generator.#DOCUMENTATION_BASE_URL}${locale2 === this.defaultLocale ? "" : `${locale2}/`}${_Generator.#DOCUMENTATION_PATH}${namespacePath}${localization.name}.html`,
+              parametersMap: new Map(methodDescriptor.parameterDescriptors.map(
+                (parameterDescriptor) => (
+                  // eslint-disable-next-line max-nested-callbacks -- Callback is empty.
+                  [parameterDescriptor.name, this.#generateLocalization(locale2, `Parameters.${parameterDescriptor.name}.`, "", (_locale, localization2) => localization2)]
+                )
+              ))
+            }))]
+          ));
           this.#functionLocalizationsMapsMap.set(namespaceFunctionName, functionLocalizationsMap);
-          this.createProxyFunction({
-            ...proxyObjectDescriptor,
-            functionName,
-            namespaceFunctionName,
-            localizationsMap: functionLocalizationsMap,
-            proxyParameterDescriptors: methodDescriptor.parameterDescriptors.map((parameterDescriptor) => {
-              const expandedParameterDescriptor = expandParameterDescriptor(parameterDescriptor);
-              const parameterName = expandedParameterDescriptor.name;
-              const parameterLocalizationsMap = this.#generateLocalizationsMap(`Parameters.${parameterName}.`, (_locale, localization) => localization);
-              this.#parameterLocalizationsMapsMap.set(`${namespaceFunctionName}.${parameterName}`, parameterLocalizationsMap);
-              return {
-                namespace,
-                parameterName,
-                localizationsMap: parameterLocalizationsMap,
-                parameterDescriptor: expandedParameterDescriptor
-              };
-            }),
-            methodDescriptor
-          });
+          this.createProxyFunction(classDescriptor, methodDescriptor, functionLocalizationsMap);
         }
       }
       success = true;
@@ -3423,16 +3671,12 @@ export {
   HexadecimalProxy,
   LibProxy,
   NumericProxy,
-  ProxyClass,
-  ProxyMethod,
-  ProxyParameter,
   RegExpProxy,
   TransformerProxy,
   Types,
   appExtensionNS,
   appExtensionResources,
   expandParameterDescriptor,
-  getClassDescriptorsMap,
   i18nAppExtensionInit,
   i18nextAppExtension
 };