@mavogel/awscdk-rootmail 0.0.335 → 0.1.0

package/node_modules/peberminta/lib/util.cjs

@@ -1,13 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function clamp(left, x, right) {
-    return Math.max(left, Math.min(x, right));
-}
-function escapeWhitespace(str) {
-    return str.replace(/(\t)|(\r)|(\n)/g, (m, t, r) => t ? '\\t' : r ? '\\r' : '\\n');
-}
-
-exports.clamp = clamp;
-exports.escapeWhitespace = escapeWhitespace;

package/node_modules/selderee/lib/Ast.d.ts

@@ -1,100 +0,0 @@
-/**
- * Specificity as defined by Selectors spec.
- *
- * {@link https://www.w3.org/TR/selectors/#specificity}
- *
- * Three levels: for id, class, tag (type).
- *
- * Extra level(s) used in HTML styling don't fit the scope of this package
- * and no space reserved for them.
- */
-export declare type Specificity = [number, number, number];
-/**
- * Container for the associated value,
- * selector specificity and position in the selectors collection.
- *
- * @typeParam V - the type of the associated value.
- */
-export declare type ValueContainer<V> = {
-    index: number;
-    specificity: Specificity;
-    value: V;
-};
-/**
- * When reached a terminal node, decision tree adds
- * the value container to the list of successful matches.
- */
-export declare type TerminalNode<V> = {
-    type: 'terminal';
-    valueContainer: ValueContainer<V>;
-};
-/**
- * Tag name has to be checked.
- * Underlying variants can be assembled
- * into a dictionary key check.
- */
-export declare type TagNameNode<V> = {
-    type: 'tagName';
-    variants: VariantNode<V>[];
-};
-/**
- * String value variant.
- */
-export declare type VariantNode<V> = {
-    type: 'variant';
-    value: string;
-    cont: DecisionTreeNode<V>[];
-};
-/**
- * Have to check the presence of an element attribute
- * with the given name.
- */
-export declare type AttrPresenceNode<V> = {
-    type: 'attrPresence';
-    name: string;
-    cont: DecisionTreeNode<V>[];
-};
-/**
- * Have to check the value of an element attribute
- * with the given name.
- * It usually requires to run all underlying matchers
- * one after another.
- */
-export declare type AttrValueNode<V> = {
-    type: 'attrValue';
-    name: string;
-    matchers: MatcherNode<V>[];
-};
-/**
- * String value matcher.
- * Contains the predicate so no need to reimplement it
- * from descriptive parameters.
- */
-export declare type MatcherNode<V> = {
-    type: 'matcher';
-    matcher: '=' | '~=' | '|=' | '^=' | '$=' | '*=';
-    modifier: 'i' | 's' | null;
-    value: string;
-    predicate: (prop: string) => boolean;
-    cont: DecisionTreeNode<V>[];
-};
-/**
- * Push next element on the stack, defined by the combinator.
- * Only `>` and `+` are expected to be supported.
- *
- * All checks are performed on the element on top of the stack.
- */
-export declare type PushElementNode<V> = {
-    type: 'pushElement';
-    combinator: '>' | '+';
-    cont: DecisionTreeNode<V>[];
-};
-/**
- * Remove the top element from the stack -
- * following checks are performed on the previous element.
- */
-export declare type PopElementNode<V> = {
-    type: 'popElement';
-    cont: DecisionTreeNode<V>[];
-};
-export declare type DecisionTreeNode<V> = TerminalNode<V> | TagNameNode<V> | AttrPresenceNode<V> | AttrValueNode<V> | PushElementNode<V> | PopElementNode<V>;

package/node_modules/selderee/lib/DecisionTree.d.ts

@@ -1,34 +0,0 @@
-import { BuilderFunction } from './Types';
-/**
- * CSS selectors decision tree.
- * Data structure that weaves similar selectors together
- * in order to minimize the number of checks required
- * to find the ones matching a given HTML element.
- *
- * Converted into a functioning implementation via plugins
- * tailored for specific DOM ASTs.
- *
- * @typeParam V - the type of values associated with selectors.
- */
-export declare class DecisionTree<V> {
-    private readonly branches;
-    /**
-     * Create new DecisionTree object.
-     *
-     * @param input - an array containing all selectors
-     * paired with associated values.
-     *
-     * @typeParam V - the type of values associated with selectors.
-     */
-    constructor(input: [string, V][]);
-    /**
-     * Turn this decision tree into a usable form.
-     *
-     * @typeParam R - return type defined by the builder function.
-     *
-     * @param builder - the builder function.
-     *
-     * @returns the decision tree in a form ready for use.
-     */
-    build<R>(builder: BuilderFunction<V, R>): R;
-}

package/node_modules/selderee/lib/Picker.d.ts

@@ -1,49 +0,0 @@
-import { ValueContainer } from './Ast';
-import { MatcherFunction } from './Types';
-/**
- * Simple wrapper around the matcher function.
- * Recommended return type for builder plugins.
- *
- * @typeParam L - the type of HTML Element in the targeted DOM AST.
- * @typeParam V - the type of associated values.
- */
-export declare class Picker<L, V> {
-    private f;
-    /**
-     * Create new Picker object.
-     *
-     * @typeParam L - the type of HTML Element in the targeted DOM AST.
-     * @typeParam V - the type of associated values.
-     *
-     * @param f - the function that matches an element
-     * and returns all associated values.
-     */
-    constructor(f: MatcherFunction<L, V>);
-    /**
-     * Run the selectors decision tree against one HTML Element
-     * and return all matched associated values
-     * along with selector specificities.
-     *
-     * Client code then decides how to further process them
-     * (sort, filter, etc).
-     *
-     * @param el - an HTML Element.
-     *
-     * @returns all associated values along with
-     * selector specificities for all matched selectors.
-     */
-    pickAll(el: L): ValueContainer<V>[];
-    /**
-     * Run the selectors decision tree against one HTML Element
-     * and choose the value from the most specific matched selector.
-     *
-     * @param el - an HTML Element.
-     *
-     * @param preferFirst - option to define which value to choose
-     * when there are multiple matches with equal specificity.
-     *
-     * @returns the value from the most specific matched selector
-     * or `null` if nothing matched.
-     */
-    pick1(el: L, preferFirst?: boolean): V | null;
-}

package/node_modules/selderee/lib/TreeifyBuilder.d.ts

@@ -1,16 +0,0 @@
-import { BuilderFunction } from './Types';
-/**
- * A {@link BuilderFunction} implementation.
- *
- * Produces a string representation of the tree
- * for testing and debug purposes.
- *
- * Only accepts `string` as the associated value type.
- * Map your input collection before creating a {@link DecisionTree}
- * if you want to use it with a different type -
- * the decision on how to stringify the value is up to you.
- *
- * @param nodes - nodes from the root level of the decision tree.
- * @returns the string representation of the tree.
- */
-export declare const treeify: BuilderFunction<string, string>;

package/node_modules/selderee/lib/Types.d.ts

@@ -1,20 +0,0 @@
-import { DecisionTreeNode, ValueContainer } from './Ast';
-/**
- * A function that turn a decision tree into a usable form.
- *
- * @typeParam V - the type of associated value.
- *
- * @typeParam R - return type for this builder
- * (Consider using {@link Picker}.)
- */
-export declare type BuilderFunction<V, R> = (nodes: DecisionTreeNode<V>[]) => R;
-/**
- * Recommended matcher function shape to implement
- * in builders.
- *
- * The elements stack is represented as the arguments array.
- *
- * @typeParam L - the type of elements in a particular DOM AST.
- * @typeParam V - the type of associated value.
- */
-export declare type MatcherFunction<L, V> = (el: L, ...tail: L[]) => ValueContainer<V>[];

package/node_modules/selderee/lib/selderee.d.ts

@@ -1,5 +0,0 @@
-export * as Ast from './Ast';
-export * as Types from './Types';
-export * as Treeify from './TreeifyBuilder';
-export * from './DecisionTree';
-export * from './Picker';

package/node_modules/strnum/CHANGELOG.md

@@ -1,40 +0,0 @@
-
-**2.2.2 / 2026-03-23**
-- fix for space string
-
-
-**2.2.1 / 2026-03-19**
-- fix false positive for eNotation when no leading zeros
-
-**2.2.0 / 2026-02-28**
-- support infinity
-
-**2.1.0 / 2025-05-01**
-- fix e-notation 
-  - to return string when invalid enotation is found. Eg `E24`
-  - to return valid number when only leading zero before e char is present
-
-**2.0.5 / 2025-02-27**
-- changes done in 1.1.2
-
-**1.1.2 / 2025-02-27**
-- fix skiplike for 0
-
-**1.1.1 / 2025-02-21**
-- All recent fixes of version 2
-
-**2.0.4 / 2025-02-20**
-- remove console log
-
-**2.0.3 / 2025-02-20**
-- fix for string which are falsly identified as e-notation
-
-**2.0.1 / 2025-02-20**
-- fix: handle only zeros
-- fix: return original string when NaN
-
-**2.0.0 / 2025-02-20**
-- Migrating to ESM modules. No functional change
-
-**1.1.0 / 2025-02-20**
-- fix (#9): support missing floating point and e notations

package/node_modules/strnum/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Natural Intelligence
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/node_modules/strnum/README.md

@@ -1,104 +0,0 @@
-# strnum
-Parse string into Number based on configuration
-
-## Users
-
-<a href="https://github.com/aws-amplify" target="_blank"><img src="https://avatars.githubusercontent.com/u/41077760?s=100&v=4"></a>
-<a href="https://github.com/astrapay" target="_blank"><img src="https://avatars.githubusercontent.com/u/90901882?s=100&v=4"></a>
-<a href="https://github.com/process-analytics" target="_blank"><img src="https://avatars.githubusercontent.com/u/60110287?s=100&v=4"></a>
-<a href="https://github.com/NaturalIntelligence" target="_blank"><img src="https://avatars.githubusercontent.com/u/16322633?s=100&v=4"></a>
-Many React Native projects and plugins
-
-## Usage
-
-```bash
-npm install strnum
-```
-```js
-const toNumber = require("strnum");
-
-toNumber(undefined) // undefined
-toNumber(null)) //null
-toNumber("")) // ""
-toNumber("string"); //"string")
-toNumber("12,12"); //"12,12")
-toNumber("12 12"); //"12 12")
-toNumber("12-12"); //"12-12")
-toNumber("12.12.12"); //"12.12.12")
-toNumber("0x2f"); //47)
-toNumber("-0x2f"); //-47)
-toNumber("0x2f", { hex :  true}); //47)
-toNumber("-0x2f", { hex :  true}); //-47)
-toNumber("0x2f", { hex :  false}); //"0x2f")
-toNumber("-0x2f", { hex :  false}); //"-0x2f")
-toNumber("06"); //6)
-toNumber("06", { leadingZeros :  true}); //6)
-toNumber("06", { leadingZeros :  false}); //"06")
-
-toNumber("006"); //6)
-toNumber("006", { leadingZeros :  true}); //6)
-toNumber("006", { leadingZeros :  false}); //"006")
-toNumber("0.0"); //0)
-toNumber("00.00"); //0)
-toNumber("0.06"); //0.06)
-toNumber("00.6"); //0.6)
-toNumber(".006"); //0.006)
-toNumber("6.0"); //6)
-toNumber("06.0"); //6)
-
-toNumber("0.0",  { leadingZeros :  false}); //0)
-toNumber("00.00",  { leadingZeros :  false}); //"00.00")
-toNumber("0.06",  { leadingZeros :  false}); //0.06)
-toNumber("00.6",  { leadingZeros :  false}); //"00.6")
-toNumber(".006", { leadingZeros :  false}); //0.006)
-toNumber("6.0"  ,  { leadingZeros :  false}); //6)
-toNumber("06.0"  ,  { leadingZeros :  false}); //"06.0")
-toNumber("-06"); //-6)
-toNumber("-06", { leadingZeros :  true}); //-6)
-toNumber("-06", { leadingZeros :  false}); //"-06")
-
-toNumber("-0.0"); //-0)
-toNumber("-00.00"); //-0)
-toNumber("-0.06"); //-0.06)
-toNumber("-00.6"); //-0.6)
-toNumber("-.006"); //-0.006)
-toNumber("-6.0"); //-6)
-toNumber("-06.0"); //-6)
-
-toNumber("-0.0"   ,  { leadingZeros :  false}); //-0)
-toNumber("-00.00",  { leadingZeros :  false}); //"-00.00")
-toNumber("-0.06",  { leadingZeros :  false}); //-0.06)
-toNumber("-00.6",  { leadingZeros :  false}); //"-00.6")
-toNumber("-.006",  {leadingZeros :  false}); //-0.006)
-toNumber("-6.0"  ,  { leadingZeros :  false}); //-6)
-toNumber("-06.0"  ,  { leadingZeros :  false}); //"-06.0")
-toNumber("420926189200190257681175017717")  ; //4.209261892001902e+29)
-toNumber("000000000000000000000000017717"  ,  { leadingZeros :  false}); //"000000000000000000000000017717")
-toNumber("000000000000000000000000017717"  ,  { leadingZeros :  true}); //17717)
-toNumber("01.0e2"  ,  { leadingZeros :  false}); //"01.0e2")
-toNumber("-01.0e2"  ,  { leadingZeros :  false}); //"-01.0e2")
-toNumber("01.0e2") ; //100)
-toNumber("-01.0e2") ; //-100)
-toNumber("1.0e2") ; //100)
-
-toNumber("-1.0e2") ; //-100)
-toNumber("1.0e-2"); //0.01)
-
-toNumber("+1212121212"); // 1212121212
-toNumber("+1212121212", { skipLike: /\+[0-9]{10}/} )); //"+1212121212"
-```
-
-Supported Options
-```js
-hex: true,          //when hexadecimal string should be parsed
-leadingZeros: true, //when number with leading zeros like 08 should be parsed. 0.0 is not impacted
-eNotation: true,    //when number with eNotation or number parsed in eNotation should be considered
-skipLike: /regex/   //when string should not be parsed when it matches the specified regular expression
-infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
-```
-
-
-# Try out our other work
-
-WishIn - You need it if negative thoughts take over all the time <br>
-<a href="https://play.google.com/store/apps/details?id=com.solothought.wishin"> <img src="https://solothought.com/products/assets/images/wishin/YouTubeThumbnail.png" width="500px"/> </a>

package/node_modules/strnum/package.json

@@ -1,31 +0,0 @@
-{
-  "name": "strnum",
-  "version": "2.2.3",
-  "description": "Parse String to Number based on configuration",
-  "type": "module",
-  "main": "strnum.js",
-  "scripts": {
-    "test": "jasmine tests/*_test.js"
-  },
-  "keywords": [
-    "string",
-    "number",
-    "parse",
-    "convert"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/NaturalIntelligence/strnum"
-  },
-  "author": "Amit Gupta (https://amitkumargupta.work/)",
-  "license": "MIT",
-  "funding": [
-    {
-      "type": "github",
-      "url": "https://github.com/sponsors/NaturalIntelligence"
-    }
-  ],
-  "devDependencies": {
-    "jasmine": "^5.6.0"
-  }
-}

package/node_modules/strnum/strnum.js

@@ -1,161 +0,0 @@
-const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
-const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
-// const octRegex = /^0x[a-z0-9]+/;
-// const binRegex = /0x[a-z0-9]+/;
-
-
-const consider = {
-    hex: true,
-    // oct: false,
-    leadingZeros: true,
-    decimalPoint: "\.",
-    eNotation: true,
-    //skipLike: /regex/,
-    infinity: "original", // "null", "infinity" (Infinity type), "string" ("Infinity" (the string literal))
-};
-
-export default function toNumber(str, options = {}) {
-    options = Object.assign({}, consider, options);
-    if (!str || typeof str !== "string") return str;
-
-    let trimmedStr = str.trim();
-
-    if (trimmedStr.length === 0) return str;
-    else if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
-    else if (trimmedStr === "0") return 0;
-    else if (options.hex && hexRegex.test(trimmedStr)) {
-        return parse_int(trimmedStr, 16);
-        // }else if (options.oct && octRegex.test(str)) {
-        //     return Number.parseInt(val, 8);
-    } else if (!isFinite(trimmedStr)) { //Infinity
-        return handleInfinity(str, Number(trimmedStr), options);
-    } else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation
-        return resolveEnotation(str, trimmedStr, options);
-        // }else if (options.parseBin && binRegex.test(str)) {
-        //     return Number.parseInt(val, 2);
-    } else {
-        //separate negative sign, leading zeros, and rest number
-        const match = numRegex.exec(trimmedStr);
-        // +00.123 => [ , '+', '00', '.123', ..
-        if (match) {
-            const sign = match[1] || "";
-            const leadingZeros = match[2];
-            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
-            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.
-                str[leadingZeros.length + 1] === "."
-                : str[leadingZeros.length] === ".";
-
-            //trim ending zeros for floating number
-            if (!options.leadingZeros //leading zeros are not allowed
-                && (leadingZeros.length > 1
-                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))) {
-                // 00, 00.3, +03.24, 03, 03.24
-                return str;
-            }
-            else {//no leading zeros or leading zeros are allowed
-                const num = Number(trimmedStr);
-                const parsedStr = String(num);
-
-                if (num === 0) return num;
-                if (parsedStr.search(/[eE]/) !== -1) { //given number is long and parsed to eNotation
-                    if (options.eNotation) return num;
-                    else return str;
-                } else if (trimmedStr.indexOf(".") !== -1) { //floating number
-                    if (parsedStr === "0") return num; //0.0
-                    else if (parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000
-                    else if (parsedStr === `${sign}${numTrimmedByZeros}`) return num;
-                    else return str;
-                }
-
-                let n = leadingZeros ? numTrimmedByZeros : trimmedStr;
-                if (leadingZeros) {
-                    // -009 => -9
-                    return (n === parsedStr) || (sign + n === parsedStr) ? num : str
-                } else {
-                    // +9
-                    return (n === parsedStr) || (n === sign + parsedStr) ? num : str
-                }
-            }
-        } else { //non-numeric string
-            return str;
-        }
-    }
-}
-
-const eNotationRegx = /^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;
-function resolveEnotation(str, trimmedStr, options) {
-    if (!options.eNotation) return str;
-    const notation = trimmedStr.match(eNotationRegx);
-    if (notation) {
-        let sign = notation[1] || "";
-        const eChar = notation[3].indexOf("e") === -1 ? "E" : "e";
-        const leadingZeros = notation[2];
-        const eAdjacentToLeadingZeros = sign ? // 0E.
-            str[leadingZeros.length + 1] === eChar
-            : str[leadingZeros.length] === eChar;
-
-        if (leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;
-        else if (leadingZeros.length === 1
-            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)) {
-            return Number(trimmedStr);
-        } else if (leadingZeros.length > 0) {
-            // Has leading zeros — only accept if leadingZeros option allows it
-            if (options.leadingZeros && !eAdjacentToLeadingZeros) {
-                trimmedStr = (notation[1] || "") + notation[3];
-                return Number(trimmedStr);
-            } else return str;
-        } else {
-            // No leading zeros — always valid e-notation, parse it
-            return Number(trimmedStr);
-        }
-    } else {
-        return str;
-    }
-}
-
-/**
- * 
- * @param {string} numStr without leading zeros
- * @returns 
- */
-function trimZeros(numStr) {
-    if (numStr && numStr.indexOf(".") !== -1) {//float
-        numStr = numStr.replace(/0+$/, ""); //remove ending zeros
-        if (numStr === ".") numStr = "0";
-        else if (numStr[0] === ".") numStr = "0" + numStr;
-        else if (numStr[numStr.length - 1] === ".") numStr = numStr.substring(0, numStr.length - 1);
-        return numStr;
-    }
-    return numStr;
-}
-
-function parse_int(numStr, base) {
-    //polyfill
-    if (parseInt) return parseInt(numStr, base);
-    else if (Number.parseInt) return Number.parseInt(numStr, base);
-    else if (window && window.parseInt) return window.parseInt(numStr, base);
-    else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")
-}
-
-/**
- * Handle infinite values based on user option
- * @param {string} str - original input string
- * @param {number} num - parsed number (Infinity or -Infinity)
- * @param {object} options - user options
- * @returns {string|number|null} based on infinity option
- */
-function handleInfinity(str, num, options) {
-    const isPositive = num === Infinity;
-
-    switch (options.infinity.toLowerCase()) {
-        case "null":
-            return null;
-        case "infinity":
-            return num; // Return Infinity or -Infinity
-        case "string":
-            return isPositive ? "Infinity" : "-Infinity";
-        case "original":
-        default:
-            return str; // Return original string like "1e1000"
-    }
-}