@aidc-toolkit/app-extension 1.0.49 → 1.0.50-beta

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,cAAc,kBAAkB,CAAC;AAEjC,mBAAmB,4BAA4B,CAAC;AAChD,mBAAmB,WAAW,CAAC;AAE/B,mBAAmB,gBAAgB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAE/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -1,4 +1,3 @@
-import{a as b}from"./chunk-MR63TJ3B.js";import{A as y,B as S,C,D as I,E as v,i as c,j as l,k as n,l as p,m as T,n as u,o as E,u as h,w as x,z as d}from"./chunk-22IRLVWO.js";import{getLogger as m,LogLevels as a,MemoryTransport as g}from"@aidc-toolkit/core";var i=class e{static APPLICATION_NAME="AIDCToolkit";static VERSION_NAME=`${e.APPLICATION_NAME}.version`;static#i=120;static#s=100;#t;#r;#o;#e;#n;#a=new WeakMap;constructor(t,r,s){this.#t=t,this.#r=r,this.#o=s;let o=!t.includes("-");this.#e=m(o?a.Info:a.Debug,{type:o?"hidden":"pretty"}),this.#n=new g(this.#e,e.#i,e.#s)}async initialize(){await this.getDocumentProperty(e.VERSION_NAME)!==this.#t&&await this.setDocumentProperty(e.VERSION_NAME,this.#t)}get version(){return this.#t}get throwError(){return this.#o}get logger(){return this.#e}get memoryTransport(){return this.#n}getProxy(t){let r=this.#a.get(t);return r===void 0&&(r=new t(this),this.#a.set(t,r)),r}validateSequenceCount(t){let r=Math.abs(t);if(r>this.#r)throw new RangeError(n.t("AppExtension.sequenceCountMustBeLessThanOrEqualTo",{sequenceCount:r,maximumSequenceCount:this.#r}))}};export{I as AlphabeticProxy,v as AlphanumericProxy,i as AppExtension,b as AppHelperProxy,y as CharacterSetCreatorProxy,d as CharacterSetValidatorProxy,C as HexadecimalProxy,T as LibProxy,E as Multiplicities,S as NumericProxy,x as RegExpProxy,h as TransformerProxy,u as Types,c as appExtensionNS,l as appExtensionResourceBundle,p as i18nAppExtensionInit,n as i18nextAppExtension};
 /*!
  * Copyright © 2024-2026 Dolphin Data Development Ltd. and AIDC Toolkit
  * contributors
@@ -15,3 +14,10 @@ import{a as b}from"./chunk-MR63TJ3B.js";import{A as y,B as S,C,D as I,E as v,i a
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export * from "./locale/i18n.js";
+export * from "./app-extension.js";
+export * from "./lib-proxy.js";
+export * from "./descriptor.js";
+export * from "./app-helper-proxy.js";
+export * from "./utility/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,cAAc,kBAAkB,CAAC;AAMjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAE/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC"}

package/dist/lib-proxy.d.ts

@@ -0,0 +1,121 @@
+import type { BigInteger } from "./app-extension-options.js";
+import type { AppExtension } from "./app-extension.js";
+import type { Matrix, MatrixResult, SingletonResult } from "./type.js";
+/**
+ * Library proxy.
+ */
+export declare abstract class LibProxy {
+    #private;
+    /**
+     * Constructor.
+     *
+     * @param appExtension
+     * Application extension.
+     */
+    constructor(appExtension: AppExtension);
+    /**
+     * Get the application extension.
+     */
+    get appExtension(): AppExtension;
+    /**
+     * Map big integer to another type if necessary.
+     *
+     * @param value
+     * Big integer value to map.
+     *
+     * @returns
+     * Mapped big integer value.
+     */
+    mapBigInt(value: bigint): SingletonResult<BigInteger>;
+    /**
+     * Call a singleton result function with error handling.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Callback return or error if errors are not thrown.
+     */
+    singletonResult<TResult>(callback: () => SingletonResult<TResult>): SingletonResult<TResult>;
+    /**
+     * Call a matrix result function with error handling.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param valueCallback
+     * Callback to process value.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    protected matrixResult<TValue, TResult>(matrixValues: Matrix<TValue>, valueCallback: (value: TValue) => SingletonResult<TResult>): MatrixResult<TResult>;
+    /**
+     * Map a matrix of validate string results to boolean. If the string is empty, the result is true, indicating that
+     * there is no error.
+     *
+     * @param matrixValidateResults
+     * Matrix of results from a call to a validate function.
+     *
+     * @returns
+     * Matrix of boolean values, true if corresponding string is empty.
+     */
+    protected isValidString(matrixValidateResults: MatrixResult<string>): Matrix<boolean>;
+    /**
+     * Set up a mapping and call a matrix result function with error handling.
+     *
+     * @param setUpCallback
+     * Callback to set up the mapping.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param valueCallback
+     * Callback to process value.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    protected setUpMatrixResult<TSetup, TValue, TResult>(setUpCallback: () => TSetup, matrixValues: Matrix<TValue>, valueCallback: (setup: TSetup, value: TValue) => SingletonResult<TResult>): MatrixResult<TResult>;
+    /**
+     * Call an array result function with error handling and map to a matrix.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    protected arrayResult<TValue, TResult>(matrixValues: Matrix<TValue>, callback: (value: TValue) => Array<SingletonResult<TResult>>): MatrixResult<TResult>;
+    /**
+     * Call a matrix result function with error handling and map a non-error result to an empty string and {@linkcode
+     * RangeError} to the string error message.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param callback
+     * Callback that either returns or throws an exception.
+     *
+     * @returns
+     * Matrix of strings.
+     */
+    protected matrixErrorResult<TValue>(matrixValues: Matrix<TValue>, callback: (value: TValue) => void): Matrix<string>;
+    /**
+     * Call an iterable result function with error handling and map to a matrix. Although the natural approach would be
+     * to map to a single-element array containing an array of *N* results (i.e., [[r0, r1, r2, ..., r*N*]]), this is
+     * rendered visually as a single row. The more readable approach is as a single column, so the mapping is to an
+     * *N*-element array of single-element result arrays (i.e., [[r0], [r1], [r2], ..., [r*N*]]).
+     *
+     * @param iterableCallback
+     * Iterable callback.
+     *
+     * @returns
+     * Matrix of callback results.
+     */
+    protected iterableResult<TResult>(iterableCallback: () => Iterable<SingletonResult<TResult>>): MatrixResult<TResult>;
+}
+//# sourceMappingURL=lib-proxy.d.ts.map

package/dist/lib-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib-proxy.d.ts","sourceRoot":"","sources":["../src/lib-proxy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEvE;;GAEG;AACH,8BAAsB,QAAQ;;IAM1B;;;;;OAKG;gBACS,YAAY,EAAE,YAAY;IAItC;;OAEG;IACH,IAAI,YAAY,IAAI,YAAY,CAE/B;IAED;;;;;;;;OAQG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAAC,UAAU,CAAC;IAkCrD;;;;;;;;OAQG;IACH,eAAe,CAAC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC,OAAO,CAAC,GAAG,eAAe,CAAC,OAAO,CAAC;IAY5F;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,eAAe,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC;IAIxJ;;;;;;;;;OASG;IACH,SAAS,CAAC,aAAa,CAAC,qBAAqB,EAAE,YAAY,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC;IAIrF;;;;;;;;;;;;;;OAcG;IACH,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,eAAe,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC;IA8BjN;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC;IA0CzJ;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC;IAuBpH;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,cAAc,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC;CAWvH"}

package/dist/lib-proxy.js

@@ -0,0 +1,259 @@
+import { mapIterable } from "@aidc-toolkit/utility";
+import { i18nextAppExtension } from "./locale/i18n.js";
+/**
+ * Library proxy.
+ */
+export class LibProxy {
+    /**
+     * Application extension.
+     */
+    #appExtension;
+    /**
+     * Constructor.
+     *
+     * @param appExtension
+     * Application extension.
+     */
+    constructor(appExtension) {
+        this.#appExtension = appExtension;
+    }
+    /**
+     * Get the application extension.
+     */
+    get appExtension() {
+        return this.#appExtension;
+    }
+    /**
+     * Map big integer to another type if necessary.
+     *
+     * @param value
+     * Big integer value to map.
+     *
+     * @returns
+     * Mapped big integer value.
+     */
+    mapBigInt(value) {
+        return this.#appExtension.mapBigInt(value);
+    }
+    /**
+     * Handle an error thrown by a function call. Return type is {@linkcode SingletonResult} to ensure assignment
+     * compatibility.
+     *
+     * @param e
+     * Error.
+     *
+     * @returns
+     * Error if errors are not thrown.
+     */
+    #handleError(e) {
+        let result;
+        if (e instanceof RangeError) {
+            const error = this.#appExtension.mapRangeError(e);
+            if (this.#appExtension.throwError) {
+                // eslint-disable-next-line @typescript-eslint/only-throw-error -- Type is determined by application.
+                throw error;
+            }
+            result = error;
+        }
+        else {
+            // Unknown error; pass on to application extension.
+            result = this.appExtension.handleError(e instanceof Error ? e.message : String(e));
+        }
+        return result;
+    }
+    /**
+     * Call a singleton result function with error handling.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Callback return or error if errors are not thrown.
+     */
+    singletonResult(callback) {
+        let result;
+        try {
+            result = callback();
+        }
+        catch (e) {
+            result = this.#handleError(e);
+        }
+        return result;
+    }
+    /**
+     * Call a matrix result function with error handling.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param valueCallback
+     * Callback to process value.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    matrixResult(matrixValues, valueCallback) {
+        return matrixValues.map(rowValues => rowValues.map(value => this.singletonResult(() => valueCallback(value))));
+    }
+    /**
+     * Map a matrix of validate string results to boolean. If the string is empty, the result is true, indicating that
+     * there is no error.
+     *
+     * @param matrixValidateResults
+     * Matrix of results from a call to a validate function.
+     *
+     * @returns
+     * Matrix of boolean values, true if corresponding string is empty.
+     */
+    isValidString(matrixValidateResults) {
+        return matrixValidateResults.map(rowValues => rowValues.map(value => (validateResult => validateResult === "")(value)));
+    }
+    /**
+     * Set up a mapping and call a matrix result function with error handling.
+     *
+     * @param setUpCallback
+     * Callback to set up the mapping.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param valueCallback
+     * Callback to process value.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    setUpMatrixResult(setUpCallback, matrixValues, valueCallback) {
+        let result;
+        try {
+            result = matrixValues.map(rowValues => rowValues.map(value => this.singletonResult(() => valueCallback(setUpCallback(), value))));
+        }
+        catch (e) {
+            result = [[this.#handleError(e)]];
+        }
+        return result;
+    }
+    /**
+     * Do the callback for an array return.
+     *
+     * @param value
+     * Value.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Callback result or error as array if errors are not thrown.
+     */
+    #arrayCallback(value, callback) {
+        const result = this.singletonResult(() => callback(value));
+        return result instanceof Array ? result : [result];
+    }
+    /**
+     * Call an array result function with error handling and map to a matrix.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param callback
+     * Callback.
+     *
+     * @returns
+     * Matrix of callback results and errors if errors are not thrown.
+     */
+    arrayResult(matrixValues, callback) {
+        let result;
+        if (matrixValues.length === 0) {
+            // Special case; unlikely to occur.
+            result = [[]];
+        }
+        else if (matrixValues.length === 1) {
+            result = [];
+            matrixValues[0].forEach((value, columnIndex) => {
+                const arrayResult = this.#arrayCallback(value, callback);
+                arrayResult.forEach((resultError, rowIndex) => {
+                    // Append a row if necessary.
+                    if (result.length <= rowIndex) {
+                        result.push([]);
+                    }
+                    // Assignment will automatically expand row to the number of columns in the matrix.
+                    result[rowIndex][columnIndex] = resultError;
+                });
+            });
+        }
+        else {
+            result = matrixValues.map((rowValue) => {
+                let arrayResult;
+                if (rowValue.length === 0) {
+                    // Special case; unlikely to occur.
+                    arrayResult = [];
+                }
+                else if (rowValue.length === 1) {
+                    arrayResult = this.#arrayCallback(rowValue[0], callback);
+                }
+                else {
+                    arrayResult = [this.#handleError(new RangeError(i18nextAppExtension.t("Proxy.matrixMustBeArray")))];
+                }
+                return arrayResult;
+            });
+        }
+        return result;
+    }
+    /**
+     * Call a matrix result function with error handling and map a non-error result to an empty string and {@linkcode
+     * RangeError} to the string error message.
+     *
+     * @param matrixValues
+     * Matrix of values.
+     *
+     * @param callback
+     * Callback that either returns or throws an exception.
+     *
+     * @returns
+     * Matrix of strings.
+     */
+    matrixErrorResult(matrixValues, callback) {
+        return matrixValues.map(rowValues => rowValues.map((value) => {
+            let result;
+            try {
+                callback(value);
+                // No error; return empty string.
+                result = "";
+            }
+            catch (e) {
+                if (e instanceof RangeError) {
+                    // Library error; return error message.
+                    result = e.message;
+                }
+                else {
+                    // Unknown error; pass up the stack.
+                    throw e;
+                }
+            }
+            return result;
+        }));
+    }
+    /**
+     * Call an iterable result function with error handling and map to a matrix. Although the natural approach would be
+     * to map to a single-element array containing an array of *N* results (i.e., [[r0, r1, r2, ..., r*N*]]), this is
+     * rendered visually as a single row. The more readable approach is as a single column, so the mapping is to an
+     * *N*-element array of single-element result arrays (i.e., [[r0], [r1], [r2], ..., [r*N*]]).
+     *
+     * @param iterableCallback
+     * Iterable callback.
+     *
+     * @returns
+     * Matrix of callback results.
+     */
+    iterableResult(iterableCallback) {
+        let result;
+        try {
+            result = Array.from(mapIterable(iterableCallback(), result => [result]));
+        }
+        catch (e) {
+            result = [[this.#handleError(e)]];
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=lib-proxy.js.map

package/dist/lib-proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib-proxy.js","sourceRoot":"","sources":["../src/lib-proxy.ts"],"names":[],"mappings":"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"}

package/dist/{index.d.cts → locale/en/locale-resources.d.ts}

@@ -1,11 +1,3 @@
-import { I18nLanguageDetector, Nullishable } from '@aidc-toolkit/core';
-import { Resource, i18n } from 'i18next';
-import { E as ErrorExtends, L as LibProxy, M as Matrix, a as MatrixResult, S as StringProxy } from './character-set-proxy-BOW94WCe.cjs';
-export { A as Address, j as AlphabeticProxy, k as AlphanumericProxy, h as AppExtension, i as CharacterSetCreatorProxy, C as CharacterSetValidatorProxy, H as HexadecimalProxy, N as NumericProxy, R as Range, b as Sheet, c as SheetAddress, d as SheetRange, e as SingletonResult, g as StreamingCancelledCallback, f as StreamingConsumerCallback } from './character-set-proxy-BOW94WCe.cjs';
-export { C as ClassDescriptor, E as ExtendsParameterDescriptor, e as MethodDescriptor, M as Multiplicities, d as Multiplicity, c as MultiplicityKey, P as ParameterDescriptor, R as ReplacementParameterDescriptor, b as Type, a as TypeKey, T as Types } from './descriptor-D6tZH-vc.cjs';
-import '@aidc-toolkit/utility';
-import 'tslog';
-
 declare const _default: {
     AppExtension: {
         sequenceCountMustBeLessThanOrEqualTo: string;
@@ -759,108 +751,5 @@ declare const _default: {
         };
     };
 };
-
-declare const appExtensionNS = "aidct_app_extension";
-/**
- * Locale resources type is extracted from the English locale resources object.
- */
-type AppExtensionLocaleResources = typeof _default;
-/**
- * App extension resource bundle.
- */
-declare const appExtensionResourceBundle: Resource;
-declare const i18nextAppExtension: i18n;
-/**
- * Initialize internationalization.
- *
- * @param languageDetector
- * Language detector.
- *
- * @param debug
- * Debug setting.
- *
- * @returns
- * App extension resource bundle.
- */
-declare function i18nAppExtensionInit(languageDetector: I18nLanguageDetector, debug?: boolean): Promise<Resource>;
-
-/**
- * Application utilities.
- *
- * @template ThrowError
- * If true, errors are reported through the throw/catch mechanism.
- *
- * @template TError
- * Error type.
- *
- * @template TInvocationContext
- * Application-specific invocation context type.
- *
- * @template TStreamingInvocationContext
- * Application-specific streaming invocation context type.
- *
- * @template TBigInt
- * Type to which big integer is mapped.
- */
-declare class AppHelperProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
-    #private;
-    /**
-     * Get the version.
-     *
-     * @returns
-     * Version.
-     */
-    version(): string;
-    /**
-     * Spill a one-dimensional matrix to fit a rectangle within a given maximum height and width.
-     *
-     * @param arrayValues
-     * Matrix values. Matrix is length 1 or contains arrays of length 1 with the values.
-     *
-     * @param maximumHeight
-     * Maximum height.
-     *
-     * @param maximumWidth
-     * Maximum width.
-     *
-     * @param invocationContext
-     * Invocation context.
-     *
-     * @returns
-     * Matrix spilled within maximum height and maximum width.
-     */
-    spill(arrayValues: Matrix<unknown>, maximumHeight: Nullishable<number>, maximumWidth: Nullishable<number>, invocationContext: Nullishable<TInvocationContext>): Promise<MatrixResult<unknown, ThrowError, TError>>;
-    /**
-     * Get the logger messages. This is a snapshot, with the option to change the log level for the next call.
-     *
-     * @param logLevelString
-     * Log level as string.
-     *
-     * @returns
-     * Logger messages.
-     */
-    loggerMessages(logLevelString: Nullishable<string>): MatrixResult<string, ThrowError, TError>;
-    /**
-     * Get the logger messages as a stream.
-     *
-     * @param logLevelString
-     * Log level as string.
-     *
-     * @param streamingInvocationContext
-     * Streaming invocation context.
-     */
-    loggerStream(logLevelString: Nullishable<string>, streamingInvocationContext: Nullishable<TStreamingInvocationContext>): void;
-}
-
-declare class TransformerProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends LibProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
-    forward(domain: number | bigint, matrixValues: Matrix<number | bigint>, tweak: Nullishable<number | bigint>): MatrixResult<TBigInt, ThrowError, TError>;
-    forwardSequence(domain: number | bigint, startValue: number, count: number, tweak: Nullishable<number | bigint>): MatrixResult<TBigInt, ThrowError, TError>;
-    reverse(domain: number | bigint, matrixTransformedValues: Matrix<number | bigint>, tweak: Nullishable<number | bigint>): MatrixResult<TBigInt, ThrowError, TError>;
-}
-
-declare class RegExpProxy<ThrowError extends boolean, TError extends ErrorExtends<ThrowError>, TInvocationContext, TStreamingInvocationContext, TBigInt> extends StringProxy<ThrowError, TError, TInvocationContext, TStreamingInvocationContext, TBigInt> {
-    validate(regExp: string, matrixSs: Matrix<string>, errorMessage: Nullishable<string>): Matrix<string>;
-    isValid(regExp: string, matrixSs: Matrix<string>): Matrix<boolean>;
-}
-
-export { type AppExtensionLocaleResources, AppHelperProxy, ErrorExtends, LibProxy, Matrix, MatrixResult, RegExpProxy, TransformerProxy, appExtensionNS, appExtensionResourceBundle, i18nAppExtensionInit, i18nextAppExtension };
+export default _default;
+//# sourceMappingURL=locale-resources.d.ts.map

package/dist/locale/en/locale-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-resources.d.ts","sourceRoot":"","sources":["../../../src/locale/en/locale-resources.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBAgvBE"}