@endevops/peppol-schema 0.1.0-beta.2 → 0.1.0-beta.4

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/all-union-fields.d.ts

@@ -1,82 +0,0 @@
-import { KeysOfUnion } from "./keys-of-union.js";
-import { UnknownArray } from "./unknown-array.js";
-import { NonRecursiveType } from "./internal/type.js";
-import { Simplify } from "./simplify.js";
-import { ReadonlyKeysOfUnion, ValueOfUnion } from "./internal/object.js";
-import { SharedUnionFields } from "./shared-union-fields.js";
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/all-union-fields.d.ts
-/**
-Create a type with all fields from a union of object types.
-
-Use-cases:
-- You want a safe object type where each key exists in the union object.
-
-@example
-```
-import type {AllUnionFields} from 'type-fest';
-
-type Cat = {
-	name: string;
-	type: 'cat';
-	catType: string;
-};
-
-type Dog = {
-	name: string;
-	type: 'dog';
-	dogType: string;
-};
-
-function displayPetInfo(petInfo: Cat | Dog) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat';
-	// 	catType: string;
-	// } | {
-	// 	name: string;
-	// 	type: 'dog';
-	// 	dogType: string;
-	// }
-
-	console.log('name:', petInfo.name);
-	console.log('type:', petInfo.type);
-
-	// TypeScript complains about `catType` and `dogType` not existing on type `Cat | Dog`.
-	// @ts-expect-error
-	console.log('animal type:', petInfo.catType ?? petInfo.dogType);
-}
-
-function displayPetInfoWithAllUnionFields(petInfo: AllUnionFields<Cat | Dog>) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat' | 'dog';
-	// 	catType?: string;
-	// 	dogType?: string;
-	// }
-
-	console.log('name:', petInfo.name);
-	console.log('type:', petInfo.type);
-
-	// No TypeScript error.
-	console.log('animal type:', petInfo.catType ?? petInfo.dogType);
-}
-```
-
-@see {@link SharedUnionFields}
-
-@category Object
-@category Union
-*/
-export type AllUnionFields<Union> = Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends (infer SkippedMembers) ? Exclude<Union, SkippedMembers> extends (infer RelevantMembers) ?
-// eslint-disable-line @stylistic/operator-linebreak
-SkippedMembers | Simplify<
-// Include fields that are common in all union members
-SharedUnionFields<RelevantMembers> &
-// Include readonly fields present in any union member
-{ readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P & KeysOfUnion<RelevantMembers>>; } &
-// Include remaining fields that are neither common nor readonly
-{ [P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>; }> : never : never;
-//#endregion
-//# sourceMappingURL=all-union-fields.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/all-union-fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"all-union-fields.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/all-union-fields.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAsEY,eAAe,SAC1B,QAAQ,OAAO,mBAAmB,gCAAgC,uBAAuB,6BAA4B,kBAClH,QAAQ,OAAO,+BAA8B;;AAE5C,iBACA;;AAED,kBAAkB;;YAGP,KAAK,oBAAoB,oBAAoB,aAAa,iBAAiB,IAAI,YAAY;;GAIpG,KAAK,QAAQ,YAAY,kBAAkB,oBAAoB,yBAAyB,oBAAoB,aAAa,iBAAiB"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/object.d.ts

@@ -1,36 +0,0 @@
-import { KeysOfUnion } from "../keys-of-union.js";
-import { IsEqual } from "../is-equal.js";
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/object.d.ts
-/**
-Extract all possible values for a given key from a union of object types.
-
-@example
-```
-type Statuses = ValueOfUnion<{id: 1; status: 'open'} | {id: 2; status: 'closed'}, 'status'>;
-//=> "open" | "closed"
-```
-*/
-export type ValueOfUnion<Union, Key extends KeysOfUnion<Union>> = Union extends unknown ? Key extends keyof Union ? Union[Key] : never : never;
-/**
-Extract all readonly keys from a union of object types.
-
-@example
-```
-type User = {
-	readonly id: string;
-	name: string;
-};
-
-type Post = {
-	readonly id: string;
-	readonly author: string;
-	body: string;
-};
-
-type ReadonlyKeys = ReadonlyKeysOfUnion<User | Post>;
-//=> "id" | "author"
-```
-*/
-export type ReadonlyKeysOfUnion<Union> = Union extends unknown ? keyof { [Key in keyof Union as IsEqual<{ [K in Key]: Union[Key]; }, { readonly [K in Key]: Union[Key]; }> extends true ? Key : never]: never; } : never;
-//#endregion
-//# sourceMappingURL=object.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/object.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object.d.ts","names":[],"sources":["../../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/object.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;YA+IY,aAAa,OAAO,YAAY,YAAY,UACvD,wBAAwB,kBAAkB,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;YAsB7C,oBAAoB,SAAS,iCACvC,aAAa,SAAS,WAAU,KAAK,MAAM,MAAM,qBAAkB,KAAK,MAAM,MAAM,wBAAsB"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/type.d.ts

@@ -1,12 +0,0 @@
-import { Primitive } from "../primitive.js";
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/type.d.ts
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-export type BuiltIns = Primitive | void | Date | RegExp;
-/**
-Matches non-recursive types.
-*/
-export type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown) | Promise<unknown>;
-//#endregion
-//# sourceMappingURL=type.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type.d.ts","names":[],"sources":["../../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/type.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;YAQY,WAAW,mBAAmB,OAAO;;;;YAKrC,mBAAmB,WAAW,oBAAoB,iCAAiC"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-equal.d.ts

@@ -1,32 +0,0 @@
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-equal.d.ts
-/**
-Returns a boolean for whether the two given types are equal.
-
-@link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
-@link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
-
-Use-cases:
-- If you want to make a conditional branch based on the result of a comparison of two types.
-
-@example
-```
-import type {IsEqual} from 'type-fest';
-
-// This type returns a boolean for whether the given array includes the given item.
-// `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
-type Includes<Value extends readonly any[], Item> =
-	Value extends readonly [Value[0], ...infer rest]
-		? IsEqual<Value[0], Item> extends true
-			? true
-			: Includes<rest, Item>
-		: false;
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : false;
-// This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
-type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
-//#endregion
-//# sourceMappingURL=is-equal.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-equal.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-equal.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;YA0BY,QAAQ,GAAG,MACrB,YAAY,MACT,YAAY,KACZ,SAAS,GAAG;;KAKZ,SAAS,GAAG,OACd,QAAQ,UAAU,IAAI,IAAI,qBAC1B,QAAQ,UAAU,IAAI,IAAI"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-never.d.ts

@@ -1,57 +0,0 @@
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-never.d.ts
-/**
-Returns a boolean for whether the given type is `never`.
-
-@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
-@link https://stackoverflow.com/a/53984913/10292952
-@link https://www.zhenghao.io/posts/ts-never
-
-Useful in type utilities, such as checking if something does not occur.
-
-@example
-```
-import type {IsNever, And} from 'type-fest';
-
-type A = IsNever<never>;
-//=> true
-
-type B = IsNever<any>;
-//=> false
-
-type C = IsNever<unknown>;
-//=> false
-
-type D = IsNever<never[]>;
-//=> false
-
-type E = IsNever<object>;
-//=> false
-
-type F = IsNever<string>;
-//=> false
-```
-
-@example
-```
-import type {IsNever} from 'type-fest';
-
-type IsTrue<T> = T extends true ? true : false;
-
-// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
-type A = IsTrue<never>;
-//=> never
-
-// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
-type IsTrueFixed<T> =
-	IsNever<T> extends true ? false : T extends true ? true : false;
-
-type B = IsTrueFixed<never>;
-//=> false
-```
-
-@category Type Guard
-@category Utilities
-*/
-export type IsNever<T> = [T] extends [never] ? true : false;
-//#endregion
-//# sourceMappingURL=is-never.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-never.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-never.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-never.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAqDY,QAAQ,MAAM"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/keys-of-union.d.ts

@@ -1,44 +0,0 @@
-import { UnionToIntersection } from "./union-to-intersection.js";
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/keys-of-union.d.ts
-/**
-Create a union of all keys from a given type, even those exclusive to specific union members.
-
-Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
-
-@link https://stackoverflow.com/a/49402091
-
-@example
-```
-import type {KeysOfUnion} from 'type-fest';
-
-type A = {
-	common: string;
-	a: number;
-};
-
-type B = {
-	common: string;
-	b: string;
-};
-
-type C = {
-	common: string;
-	c: boolean;
-};
-
-type Union = A | B | C;
-
-type CommonKeys = keyof Union;
-//=> 'common'
-
-type AllKeys = KeysOfUnion<Union>;
-//=> 'common' | 'a' | 'b' | 'c'
-```
-
-@category Object
-*/
-export type KeysOfUnion<ObjectType> =
-// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
-keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
-//#endregion
-//# sourceMappingURL=keys-of-union.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/keys-of-union.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys-of-union.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/keys-of-union.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuCY,YAAY;;MAEjB,oBAAoB,6BAA6B,aAAa"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/primitive.d.ts

@@ -1,9 +0,0 @@
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/primitive.d.ts
-/**
-Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
-
-@category Type
-*/
-export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-//#endregion
-//# sourceMappingURL=primitive.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/primitive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"primitive.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/primitive.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;YAKY"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/shared-union-fields.d.ts

@@ -1,71 +0,0 @@
-import { IsNever } from "./is-never.js";
-import { UnknownArray } from "./unknown-array.js";
-import { NonRecursiveType } from "./internal/type.js";
-import { Simplify } from "./simplify.js";
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/shared-union-fields.d.ts
-/**
-Create a type with shared fields from a union of object types.
-
-Use-cases:
-- You want a safe object type where each key exists in the union object.
-- You want to focus on the common fields of the union type and don't want to have to care about the other fields.
-
-@example
-```
-import type {SharedUnionFields} from 'type-fest';
-
-type Cat = {
-	name: string;
-	type: 'cat';
-	catType: string;
-};
-
-type Dog = {
-	name: string;
-	type: 'dog';
-	dogType: string;
-};
-
-function displayPetInfo(petInfo: Cat | Dog) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat';
-	// 	catType: string; // Needn't care about this field, because it's not a common pet info field.
-	// } | {
-	// 	name: string;
-	// 	type: 'dog';
-	// 	dogType: string; // Needn't care about this field, because it's not a common pet info field.
-	// }
-
-	// petInfo type is complex and have some needless fields
-
-	console.log('name:', petInfo.name);
-	console.log('type:', petInfo.type);
-}
-
-function displayPetInfoWithSharedUnionFields(petInfo: SharedUnionFields<Cat | Dog>) {
-	// typeof petInfo =>
-	// {
-	// 	name: string;
-	// 	type: 'cat' | 'dog';
-	// }
-
-	// petInfo type is simple and clear
-
-	console.log('name:', petInfo.name);
-	console.log('type:', petInfo.type);
-}
-```
-
-@see {@link SharedUnionFieldsDeep}
-@see {@link AllUnionFields}
-
-@category Object
-@category Union
-*/
-export type SharedUnionFields<Union> = Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends (infer SkippedMembers) ? Exclude<Union, SkippedMembers> extends (infer RelevantMembers) ?
-// eslint-disable-line @stylistic/operator-linebreak
-SkippedMembers | (IsNever<RelevantMembers> extends true ? never : Simplify<Pick<RelevantMembers, keyof RelevantMembers>>) : never : never;
-//#endregion
-//# sourceMappingURL=shared-union-fields.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/shared-union-fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared-union-fields.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/shared-union-fields.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAmEY,kBAAkB,SAC7B,QAAQ,OAAO,mBAAmB,gCAAgC,uBAAuB,6BAA4B,kBAClH,QAAQ,OAAO,+BAA8B;;AAE5C,kBACC,QAAQ,wCAER,SAAS,KAAK,uBAAuB"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/simplify.d.ts

@@ -1,62 +0,0 @@
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/simplify.d.ts
-/**
-Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-type PositionProps = {
-	top: number;
-	left: number;
-};
-
-type SizeProps = {
-	width: number;
-	height: number;
-};
-
-// In your editor, hovering over `Props` will show a flattened object with all the properties.
-type Props = Simplify<PositionProps & SizeProps>;
-```
-
-Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
-
-If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
-
-@example
-```
-import type {Simplify} from 'type-fest';
-
-interface SomeInterface {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-}
-
-type SomeType = {
-	foo: number;
-	bar?: string;
-	baz: number | undefined;
-};
-
-const literal = {foo: 123, bar: 'hello', baz: 456};
-const someType: SomeType = literal;
-const someInterface: SomeInterface = literal;
-
-declare function fn(object: Record<string, unknown>): void;
-
-fn(literal); // Good: literal object type is sealed
-fn(someType); // Good: type is sealed
-// @ts-expect-error
-fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
-fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
-```
-
-@link https://github.com/microsoft/TypeScript/issues/15300
-@see {@link SimplifyDeep}
-@category Object
-*/
-export type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
-//#endregion
-//# sourceMappingURL=simplify.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/simplify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simplify.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/simplify.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA0DY,SAAS,QAAO,iBAAiB,IAAI,EAAE"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/union-to-intersection.d.ts

@@ -1,35 +0,0 @@
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/union-to-intersection.d.ts
-/**
-Convert a union type to an intersection type.
-
-Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
-
-@example
-```
-import type {UnionToIntersection} from 'type-fest';
-
-type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
-
-type Intersection = UnionToIntersection<Union>;
-//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
-```
-
-@category Type
-*/
-export type UnionToIntersection<Union> = (
-// `extends unknown` is always going to be the case and is used to convert the
-// `Union` into a [distributive conditional
-// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
-Union extends unknown ?
-// The union type is used as the only argument to a function since the union
-// of function arguments is an intersection.
-(distributedUnion: Union) => void :
-// This won't happen.
-never
-// Infer the `Intersection` type since TypeScript represents the positional
-// arguments of unions of functions as an intersection of the union.
-) extends ((mergedIntersection: infer Intersection) => void) ?
-// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
-Intersection & Union : never;
-//#endregion
-//# sourceMappingURL=union-to-intersection.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/union-to-intersection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"union-to-intersection.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/union-to-intersection.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;YAiBY,oBAAoB;;;;AAI/B;;;CAGI,kBAAkB;;;;;YAKX,0BAA0B;;AAEnC,eAAe"}

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/unknown-array.d.ts

@@ -1,28 +0,0 @@
-//#region node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/unknown-array.d.ts
-/**
-Represents an array with `unknown` value.
-
-Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
-
-@example
-```
-import type {UnknownArray} from 'type-fest';
-
-type IsArray<T> = T extends UnknownArray ? true : false;
-
-type A = IsArray<['foo']>;
-//=> true
-
-type B = IsArray<readonly number[]>;
-//=> true
-
-type C = IsArray<string>;
-//=> false
-```
-
-@category Type
-@category Array
-*/
-export type UnknownArray = readonly unknown[];
-//#endregion
-//# sourceMappingURL=unknown-array.d.ts.map

package/dist/node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/unknown-array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unknown-array.d.ts","names":[],"sources":["../../../../../../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/unknown-array.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;YAwBY"}

package/dist/peppol-validations/add-piva.d.ts

@@ -1,7 +0,0 @@
-//#region src/peppol-validations/add-piva.d.ts
-/**
- * @description Helper function for calculating weighted sum for Italian PIVA validation.
- */
-export declare function addPIVA(arg: string, pari: number): number;
-//#endregion
-//# sourceMappingURL=add-piva.d.ts.map

package/dist/peppol-validations/add-piva.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add-piva.d.ts","names":[],"sources":["../../src/peppol-validations/add-piva.ts"],"mappings":";;;;wBAKgB,QAAQ,aAAa"}

package/dist/peppol-validations/add-piva.js

@@ -1,15 +0,0 @@
-//#region src/peppol-validations/add-piva.ts
-/**
-* @description Helper function for calculating weighted sum for Italian PIVA validation.
-*/
-function addPIVA(arg, pari) {
-	if (!/^\d+$/.test(arg)) return 0;
-	const first = Number(arg[0]);
-	const mapper = pari === 1 ? Number("0246813579"[first]) : first;
-	if (arg.length === 1) return mapper;
-	return mapper + addPIVA(arg.slice(1), pari === 0 ? 1 : 0);
-}
-//#endregion
-export { addPIVA };
-
-//# sourceMappingURL=add-piva.js.map

package/dist/peppol-validations/add-piva.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"add-piva.js","names":[],"sources":["../../src/peppol-validations/add-piva.ts"],"sourcesContent":["// NOTE: check and add valid values for the tests in `add-piva.spec.ts`\n\n/**\n * @description Helper function for calculating weighted sum for Italian PIVA validation.\n */\nexport function addPIVA(arg: string, pari: number): number {\n  if (!/^\\d+$/.test(arg)) return 0;\n  const first = Number(arg[0]);\n  const mapper = pari === 1 ? Number('0246813579'[first]) : first;\n  if (arg.length === 1) return mapper;\n  return mapper + addPIVA(arg.slice(1), pari === 0 ? 1 : 0);\n}\n"],"mappings":";;;;AAKA,SAAgB,QAAQ,KAAa,MAAsB;CACzD,IAAI,CAAC,QAAQ,KAAK,GAAG,GAAG,OAAO;CAC/B,MAAM,QAAQ,OAAO,IAAI,EAAE;CAC3B,MAAM,SAAS,SAAS,IAAI,OAAO,aAAa,MAAM,IAAI;CAC1D,IAAI,IAAI,WAAW,GAAG,OAAO;CAC7B,OAAO,SAAS,QAAQ,IAAI,MAAM,CAAC,GAAG,SAAS,IAAI,IAAI,CAAC;AAC1D"}

package/dist/peppol-validations/check-cf.d.ts

@@ -1,7 +0,0 @@
-//#region src/peppol-validations/check-cf.d.ts
-/**
- * @description Validates both 16 and 11 character Italian fiscal codes.
- */
-export declare function checkCF(arg: string): boolean;
-//#endregion
-//# sourceMappingURL=check-cf.d.ts.map

package/dist/peppol-validations/check-cf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-cf.d.ts","names":[],"sources":["../../src/peppol-validations/check-cf.ts"],"mappings":";;;;wBAMgB,QAAQ"}

package/dist/peppol-validations/check-cf.js

@@ -1,16 +0,0 @@
-import { normalizeSpace } from "./normalize-space.js";
-import { checkCF16 } from "./check-cf16.js";
-//#region src/peppol-validations/check-cf.ts
-/**
-* @description Validates both 16 and 11 character Italian fiscal codes.
-*/
-function checkCF(arg) {
-	const s = normalizeSpace(arg);
-	if (s.length === 16) return checkCF16(s);
-	if (s.length === 11) return /^\d{11}$/.test(s);
-	return false;
-}
-//#endregion
-export { checkCF };
-
-//# sourceMappingURL=check-cf.js.map

package/dist/peppol-validations/check-cf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-cf.js","names":[],"sources":["../../src/peppol-validations/check-cf.ts"],"sourcesContent":["import { checkCF16 } from './check-cf16';\nimport { normalizeSpace } from './normalize-space';\n\n/**\n * @description Validates both 16 and 11 character Italian fiscal codes.\n */\nexport function checkCF(arg: string): boolean {\n  const s = normalizeSpace(arg);\n  if (s.length === 16) return checkCF16(s);\n  if (s.length === 11) return /^\\d{11}$/.test(s);\n  return false;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,QAAQ,KAAsB;CAC5C,MAAM,IAAI,eAAe,GAAG;CAC5B,IAAI,EAAE,WAAW,IAAI,OAAO,UAAU,CAAC;CACvC,IAAI,EAAE,WAAW,IAAI,OAAO,WAAW,KAAK,CAAC;CAC7C,OAAO;AACT"}

package/dist/peppol-validations/check-cf16.d.ts

@@ -1,7 +0,0 @@
-//#region src/peppol-validations/check-cf16.d.ts
-/**
- * @description Validates 16-character Italian fiscal codes.
- */
-export declare function checkCF16(arg: string): boolean;
-//#endregion
-//# sourceMappingURL=check-cf16.d.ts.map

package/dist/peppol-validations/check-cf16.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-cf16.d.ts","names":[],"sources":["../../src/peppol-validations/check-cf16.ts"],"mappings":";;;;wBAKgB,UAAU"}

package/dist/peppol-validations/check-cf16.js

@@ -1,15 +0,0 @@
-import { normalizeSpace } from "./normalize-space.js";
-//#region src/peppol-validations/check-cf16.ts
-/**
-* @description Validates 16-character Italian fiscal codes.
-*/
-function checkCF16(arg) {
-	const s = normalizeSpace(arg);
-	if (s.length !== 16) return false;
-	if (!/^[A-Za-z]{6}\d{2}[A-Za-z]\d{2}[A-Za-z]\d{3}[A-Za-z]$/.test(s)) return false;
-	return true;
-}
-//#endregion
-export { checkCF16 };
-
-//# sourceMappingURL=check-cf16.js.map

package/dist/peppol-validations/check-cf16.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-cf16.js","names":[],"sources":["../../src/peppol-validations/check-cf16.ts"],"sourcesContent":["import { normalizeSpace } from './normalize-space';\n\n/**\n * @description Validates 16-character Italian fiscal codes.\n */\nexport function checkCF16(arg: string): boolean {\n  const s = normalizeSpace(arg);\n  if (s.length !== 16) return false;\n  if (!/^[A-Za-z]{6}\\d{2}[A-Za-z]\\d{2}[A-Za-z]\\d{3}[A-Za-z]$/.test(s)) return false;\n  return true;\n}\n"],"mappings":";;;;;AAKA,SAAgB,UAAU,KAAsB;CAC9C,MAAM,IAAI,eAAe,GAAG;CAC5B,IAAI,EAAE,WAAW,IAAI,OAAO;CAC5B,IAAI,CAAC,uDAAuD,KAAK,CAAC,GAAG,OAAO;CAC5E,OAAO;AACT"}

package/dist/peppol-validations/check-piva-se-it.d.ts

@@ -1,7 +0,0 @@
-//#region src/peppol-validations/check-piva-se-it.d.ts
-/**
- * @description Validates Italian VAT numbers with IT prefix.
- */
-export declare function checkPIVAseIT(arg: string): boolean;
-//#endregion
-//# sourceMappingURL=check-piva-se-it.d.ts.map

package/dist/peppol-validations/check-piva-se-it.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"check-piva-se-it.d.ts","names":[],"sources":["../../src/peppol-validations/check-piva-se-it.ts"],"mappings":";;;;wBAKgB,cAAc"}