n4s 3.1.0 → 4.0.0-dev-e266d9

package/dist/es/n4s.development.js

@@ -0,0 +1,597 @@
+import { createContext } from 'context';
+
+var assign = Object.assign;
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function bindNot(fn) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return !fn.apply(void 0, args);
+    };
+}
+
+function isNull(value) {
+    return value === null;
+}
+var isNotNull = bindNot(isNull);
+
+function isUndefined(value) {
+    return value === undefined;
+}
+var isNotUndefined = bindNot(isUndefined);
+
+function isNullish(value) {
+    return isNull(value) || isUndefined(value);
+}
+var isNotNullish = bindNot(isNullish);
+
+function isStringValue(v) {
+    return String(v) === v;
+}
+
+function endsWith(value, arg1) {
+    return isStringValue(value) && isStringValue(arg1) && value.endsWith(arg1);
+}
+var doesNotEndWith = bindNot(endsWith);
+
+function equals(value, arg1) {
+    return value === arg1;
+}
+var notEquals = bindNot(equals);
+
+function isNumeric(value) {
+    var str = String(value);
+    var num = Number(value);
+    var result = !isNaN(parseFloat(str)) && !isNaN(Number(value)) && isFinite(num);
+    return Boolean(result);
+}
+var isNotNumeric = bindNot(isNumeric);
+
+function greaterThan(value, gt) {
+    return isNumeric(value) && isNumeric(gt) && Number(value) > Number(gt);
+}
+
+function greaterThanOrEquals(value, gte) {
+    return isNumeric(value) && isNumeric(gte) && Number(value) >= Number(gte);
+}
+
+// The module is named "isArrayValue" since it
+// is conflicting with a nested npm dependency.
+// We may need to revisit this in the future.
+function isArray(value) {
+    return Boolean(Array.isArray(value));
+}
+var isNotArray = bindNot(isArray);
+
+function inside(value, arg1) {
+    if (isArray(arg1)) {
+        return arg1.indexOf(value) !== -1;
+    }
+    // both value and arg1 are strings
+    if (isStringValue(arg1) && isStringValue(value)) {
+        return arg1.indexOf(value) !== -1;
+    }
+    return false;
+}
+var notInside = bindNot(inside);
+
+function lessThanOrEquals(value, lte) {
+    return isNumeric(value) && isNumeric(lte) && Number(value) <= Number(lte);
+}
+
+function isBetween(value, min, max) {
+    return greaterThanOrEquals(value, min) && lessThanOrEquals(value, max);
+}
+var isNotBetween = bindNot(isBetween);
+
+function isBlank(value) {
+    return isNullish(value) || (isStringValue(value) && !value.trim());
+}
+var isNotBlank = bindNot(isBlank);
+
+function isBoolean(value) {
+    return !!value === value;
+}
+
+var isNotBoolean = bindNot(isBoolean);
+
+/**
+ * A safe hasOwnProperty access
+ */
+function hasOwnProperty(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function isNumber(value) {
+    return Boolean(typeof value === 'number');
+}
+var isNotNumber = bindNot(isNumber);
+
+function lengthEquals(value, arg1) {
+    return value.length === Number(arg1);
+}
+var lengthNotEquals = bindNot(lengthEquals);
+
+function isEmpty(value) {
+    if (!value) {
+        return true;
+    }
+    else if (isNumber(value)) {
+        return value === 0;
+    }
+    else if (hasOwnProperty(value, 'length')) {
+        return lengthEquals(value, 0);
+    }
+    else if (typeof value === 'object') {
+        return lengthEquals(Object.keys(value), 0);
+    }
+    return true;
+}
+var isNotEmpty = bindNot(isEmpty);
+
+/**
+ * Validates that a given value is an even number
+ */
+var isEven = function (value) {
+    if (isNumeric(value)) {
+        return value % 2 === 0;
+    }
+    return false;
+};
+
+function isNaN$1(value) {
+    return Number.isNaN(value);
+}
+var isNotNaN = bindNot(isNaN$1);
+
+function isNegative(value) {
+    if (isNumeric(value)) {
+        return Number(value) < 0;
+    }
+    return false;
+}
+var isPositive = bindNot(isNegative);
+
+/**
+ * Validates that a given value is an odd number
+ */
+var isOdd = function (value) {
+    if (isNumeric(value)) {
+        return value % 2 !== 0;
+    }
+    return false;
+};
+
+var isNotString = bindNot(isStringValue);
+
+function isTruthy(value) {
+    return !!value;
+}
+var isFalsy = bindNot(isTruthy);
+
+function lessThan(value, lt) {
+    return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);
+}
+
+function longerThan(value, arg1) {
+    return value.length > Number(arg1);
+}
+
+function longerThanOrEquals(value, arg1) {
+    return value.length >= Number(arg1);
+}
+
+function matches(value, regex) {
+    if (regex instanceof RegExp) {
+        return regex.test(value);
+    }
+    else if (isStringValue(regex)) {
+        return new RegExp(regex).test(value);
+    }
+    else {
+        return false;
+    }
+}
+var notMatches = bindNot(matches);
+
+function numberEquals(value, eq) {
+    return isNumeric(value) && isNumeric(eq) && Number(value) === Number(eq);
+}
+var numberNotEquals = bindNot(numberEquals);
+
+function condition(value, callback) {
+    try {
+        return callback(value);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+
+function shorterThan(value, arg1) {
+    return value.length < Number(arg1);
+}
+
+function shorterThanOrEquals(value, arg1) {
+    return value.length <= Number(arg1);
+}
+
+function startsWith(value, arg1) {
+    return isStringValue(value) && isStringValue(arg1) && value.startsWith(arg1);
+}
+var doesNotStartWith = bindNot(startsWith);
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, max-lines-per-function
+function rules() {
+    return {
+        condition: condition,
+        doesNotEndWith: doesNotEndWith,
+        doesNotStartWith: doesNotStartWith,
+        endsWith: endsWith,
+        equals: equals,
+        greaterThan: greaterThan,
+        greaterThanOrEquals: greaterThanOrEquals,
+        gt: greaterThan,
+        gte: greaterThanOrEquals,
+        inside: inside,
+        isArray: isArray,
+        isBetween: isBetween,
+        isBlank: isBlank,
+        isBoolean: isBoolean,
+        isEmpty: isEmpty,
+        isEven: isEven,
+        isFalsy: isFalsy,
+        isNaN: isNaN$1,
+        isNegative: isNegative,
+        isNotArray: isNotArray,
+        isNotBetween: isNotBetween,
+        isNotBlank: isNotBlank,
+        isNotBoolean: isNotBoolean,
+        isNotEmpty: isNotEmpty,
+        isNotNaN: isNotNaN,
+        isNotNull: isNotNull,
+        isNotNullish: isNotNullish,
+        isNotNumber: isNotNumber,
+        isNotNumeric: isNotNumeric,
+        isNotString: isNotString,
+        isNotUndefined: isNotUndefined,
+        isNull: isNull,
+        isNullish: isNullish,
+        isNumber: isNumber,
+        isNumeric: isNumeric,
+        isOdd: isOdd,
+        isPositive: isPositive,
+        isString: isStringValue,
+        isTruthy: isTruthy,
+        isUndefined: isUndefined,
+        lengthEquals: lengthEquals,
+        lengthNotEquals: lengthNotEquals,
+        lessThan: lessThan,
+        lessThanOrEquals: lessThanOrEquals,
+        longerThan: longerThan,
+        longerThanOrEquals: longerThanOrEquals,
+        lt: lessThan,
+        lte: lessThanOrEquals,
+        matches: matches,
+        notEquals: notEquals,
+        notInside: notInside,
+        notMatches: notMatches,
+        numberEquals: numberEquals,
+        numberNotEquals: numberNotEquals,
+        shorterThan: shorterThan,
+        shorterThanOrEquals: shorterThanOrEquals,
+        startsWith: startsWith
+    };
+}
+
+var baseRules = rules();
+function getRule(ruleName) {
+    return baseRules[ruleName];
+}
+
+function eachEnforceRule(action) {
+    for (var ruleName in baseRules) {
+        var ruleFn = getRule(ruleName);
+        if (isFunction(ruleFn)) {
+            action(ruleName, ruleFn);
+        }
+    }
+}
+
+var ctx = createContext(function (ctxRef, parentContext) {
+    var base = {
+        value: ctxRef.value,
+        meta: ctxRef.meta || {}
+    };
+    if (!parentContext) {
+        return assign(base, {
+            parent: emptyParent
+        });
+    }
+    else if (ctxRef.set) {
+        return assign(base, {
+            parent: function () { return stripContext(parentContext); }
+        });
+    }
+    return parentContext;
+});
+function stripContext(ctx) {
+    if (!ctx) {
+        return ctx;
+    }
+    return {
+        value: ctx.value,
+        meta: ctx.meta,
+        parent: ctx.parent
+    };
+}
+function emptyParent() {
+    return null;
+}
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || from);
+}
+
+function optionalFunctionValue(value) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return isFunction(value) ? value.apply(void 0, args) : value;
+}
+
+function defaultTo(callback, defaultValue) {
+    var _a;
+    return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+}
+
+/**
+ * Throws a timed out error.
+ */
+function throwError(devMessage, productionMessage) {
+    throw new Error(devMessage );
+}
+
+function isProxySupported() {
+    try {
+        return isFunction(Proxy);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+
+function ruleReturn(pass, message) {
+    var output = { pass: pass };
+    if (message) {
+        output.message = message;
+    }
+    return output;
+}
+function passing() {
+    return ruleReturn(true);
+}
+function defaultToPassing(callback) {
+    return defaultTo(callback, passing());
+}
+
+/**
+ * Transform the result of a rule into a standard format
+ */
+function transformResult(result, ruleName, value) {
+    var args = [];
+    for (var _i = 3; _i < arguments.length; _i++) {
+        args[_i - 3] = arguments[_i];
+    }
+    validateResult(result);
+    // if result is boolean
+    if (isBoolean(result)) {
+        return ruleReturn(result);
+    }
+    else {
+        return ruleReturn(result.pass, optionalFunctionValue.apply(void 0, __spreadArray([result.message, ruleName, value], args)));
+    }
+}
+function validateResult(result) {
+    // if result is boolean, or if result.pass is boolean
+    if (isBoolean(result) || (result && isBoolean(result.pass))) {
+        return;
+    }
+    throwError('Incorrect return value for rule: ' + JSON.stringify(result));
+}
+
+function enforceEager(value) {
+    var target = {};
+    if (!isProxySupported()) {
+        eachEnforceRule(function (ruleName, ruleFn) {
+            target[ruleName] = genRuleCall(target, ruleFn, ruleName);
+        });
+        return target;
+    }
+    var proxy = new Proxy(target, {
+        get: function (_, ruleName) {
+            var rule = getRule(ruleName);
+            if (rule) {
+                return genRuleCall(proxy, rule, ruleName);
+            }
+        }
+    });
+    return proxy;
+    function genRuleCall(target, rule, ruleName) {
+        return function ruleCall() {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var transformedResult = transformResult.apply(void 0, __spreadArray([ctx.run({ value: value }, function () { return rule.apply(void 0, __spreadArray([value], args)); }),
+                ruleName,
+                value], args));
+            if (!transformedResult.pass) {
+                if (isEmpty(transformedResult.message)) {
+                    throwError("enforce/" + ruleName + " failed with " + JSON.stringify(value));
+                }
+                else {
+                    // Explicitly throw a string so that vest.test can pick it up as the validation error message
+                    throw transformedResult.message;
+                }
+            }
+            return target;
+        };
+    }
+}
+
+function mapFirst(array, callback) {
+    var broke = false;
+    var breakoutValue = null;
+    for (var i = 0; i < array.length; i++) {
+        callback(array[i], breakout, i);
+        if (broke) {
+            return breakoutValue;
+        }
+    }
+    function breakout(value) {
+        broke = true;
+        breakoutValue = value;
+    }
+}
+
+// eslint-disable-next-line max-lines-per-function
+function genEnforceLazy(key) {
+    var registeredRules = [];
+    var lazyMessage;
+    return addLazyRule(key);
+    // eslint-disable-next-line max-lines-per-function
+    function addLazyRule(ruleName) {
+        // eslint-disable-next-line max-lines-per-function
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            var rule = getRule(ruleName);
+            registeredRules.push(function (value) {
+                return transformResult.apply(void 0, __spreadArray([rule.apply(void 0, __spreadArray([value], args)), ruleName, value], args));
+            });
+            var proxy = {
+                run: function (value) {
+                    return defaultToPassing(mapFirst(registeredRules, function (rule, breakout) {
+                        var _a;
+                        var res = ctx.run({ value: value }, function () { return rule(value); });
+                        if (!res.pass) {
+                            breakout(ruleReturn(!!res.pass, (_a = optionalFunctionValue(lazyMessage, value, res.message)) !== null && _a !== void 0 ? _a : res.message));
+                        }
+                    }));
+                },
+                test: function (value) { return proxy.run(value).pass; },
+                message: function (message) {
+                    if (message) {
+                        lazyMessage = message;
+                    }
+                    return proxy;
+                }
+            };
+            if (!isProxySupported()) {
+                eachEnforceRule(function (ruleName) {
+                    proxy[ruleName] = addLazyRule(ruleName);
+                });
+                return proxy;
+            }
+            // reassigning the proxy here is not pretty
+            // but it's a cleaner way of getting `run` and `test` for free
+            proxy = new Proxy(proxy, {
+                get: function (target, key) {
+                    if (getRule(key)) {
+                        return addLazyRule(key);
+                    }
+                    return target[key]; // already has `run` and `test` on it
+                }
+            });
+            return proxy;
+        };
+    }
+}
+
+/**
+ * Enforce is quite complicated, I want to explain it in detail.
+ * It is dynamic in nature, so a lot of proxy objects are involved.
+ *
+ * Enforce has two main interfaces
+ * 1. eager
+ * 2. lazy
+ *
+ * The eager interface is the most commonly used, and the easier to understand.
+ * It throws an error when a rule is not satisfied.
+ * The eager interface is declared in enforceEager.ts and it is quite simple to understand.
+ * enforce is called with a value, and the return value is a proxy object that points back to all the rules.
+ * When a rule is called, the value is mapped as its first argument, and if the rule passes, the same
+ * proxy object is returned. Otherwise, an error is thrown.
+ *
+ * The lazy interface works quite differently. It is declared in genEnforceLazy.ts.
+ * Rather than calling enforce directly, the lazy interface has all the rules as "methods" (only by proxy).
+ * Calling the first function in the chain will initialize an array of calls. It stores the different rule calls
+ * and the parameters passed to them. None of the rules are called yet.
+ * The rules are only invoked in sequence once either of these chained functions are called:
+ * 1. test(value)
+ * 2. run(value)
+ *
+ * Calling run or test will call all the rules in sequence, with the difference that test will only return a boolean value,
+ * while run will return an object with the validation result and an optional message created by the rule.
+ */
+function genEnforce() {
+    var target = {
+        context: function () { return ctx.useX(); },
+        extend: function (customRules) {
+            assign(baseRules, customRules);
+        }
+    };
+    if (!isProxySupported()) {
+        eachEnforceRule(function (ruleName) {
+            // Only on the first rule access - start the chain of calls
+            target[ruleName] = genEnforceLazy(ruleName);
+        });
+        return target;
+    }
+    return new Proxy(assign(enforceEager, target), {
+        get: function (target, key) {
+            if (key in target) {
+                return target[key];
+            }
+            if (!getRule(key)) {
+                return;
+            }
+            // Only on the first rule access - start the chain of calls
+            return genEnforceLazy(key);
+        }
+    });
+}
+var enforce = genEnforce();
+
+export { ctx, enforce };

package/dist/es/n4s.production.js

@@ -0,0 +1 @@
+import{createContext as n}from"context";var r=Object.assign;function t(n){return"function"==typeof n}function e(n){return function(){for(var r=[],t=0;t<arguments.length;t++)r[t]=arguments[t];return!n.apply(void 0,r)}}function u(n){return null===n}var i=e(u);function o(n){return void 0===n}var a=e(o);function s(n){return null===n||o(n)}var f=e(s);function c(n){return String(n)===n}function l(n,r){return c(n)&&c(r)&&n.endsWith(r)}var v=e(l);function N(n,r){return n===r}var h=e(N);function m(n){var r=Number(n);return!(isNaN(parseFloat(String(n)))||isNaN(Number(n))||!isFinite(r))}var g=e(m);function p(n,r){return m(n)&&m(r)&&Number(n)>Number(r)}function y(n,r){return m(n)&&m(r)&&Number(n)>=Number(r)}function b(n){return!!Array.isArray(n)}var d=e(b);function E(n,r){return!!(b(r)||c(r)&&c(n))&&-1!==r.indexOf(n)}var x=e(E);function O(n,r){return m(n)&&m(r)&&Number(n)<=Number(r)}function q(n,r,t){return y(n,r)&&O(n,t)}var w=e(q);function T(n){return s(n)||c(n)&&!n.trim()}var S=e(T);function B(n){return!!n===n}var P=e(B);function W(n){return"number"==typeof n}var A=e(W);function j(n,r){return n.length===Number(r)}var k=e(j);function F(n){if(n){if(W(n))return 0===n;if(Object.prototype.hasOwnProperty.call(n,"length"))return j(n,0);if("object"==typeof n)return j(Object.keys(n),0)}return!0}var I=e(F);function J(n){return Number.isNaN(n)}var R=e(J);function U(n){return!!m(n)&&0>Number(n)}var M=e(U),X=e(c);function z(n){return!!n}var C=e(z);function D(n,r){return m(n)&&m(r)&&Number(n)<Number(r)}function G(n,r){return r instanceof RegExp?r.test(n):!!c(r)&&new RegExp(r).test(n)}var H=e(G);function K(n,r){return m(n)&&m(r)&&Number(n)===Number(r)}var L=e(K);function Q(n,r){return c(n)&&c(r)&&n.startsWith(r)}var V={condition:function(n,r){try{return r(n)}catch(n){return!1}},doesNotEndWith:v,doesNotStartWith:e(Q),endsWith:l,equals:N,greaterThan:p,greaterThanOrEquals:y,gt:p,gte:y,inside:E,isArray:b,isBetween:q,isBlank:T,isBoolean:B,isEmpty:F,isEven:function(n){return!!m(n)&&0==n%2},isFalsy:C,isNaN:J,isNegative:U,isNotArray:d,isNotBetween:w,isNotBlank:S,isNotBoolean:P,isNotEmpty:I,isNotNaN:R,isNotNull:i,isNotNullish:f,isNotNumber:A,isNotNumeric:g,isNotString:X,isNotUndefined:a,isNull:u,isNullish:s,isNumber:W,isNumeric:m,isOdd:function(n){return!!m(n)&&0!=n%2},isPositive:M,isString:c,isTruthy:z,isUndefined:o,lengthEquals:j,lengthNotEquals:k,lessThan:D,lessThanOrEquals:O,longerThan:function(n,r){return n.length>Number(r)},longerThanOrEquals:function(n,r){return n.length>=Number(r)},lt:D,lte:O,matches:G,notEquals:h,notInside:x,notMatches:H,numberEquals:K,numberNotEquals:L,shorterThan:function(n,r){return n.length<Number(r)},shorterThanOrEquals:function(n,r){return n.length<=Number(r)},startsWith:Q};function Y(n){for(var r in V){var e=V[r];t(e)&&n(r,e)}}var Z=n((function(n,t){var e={value:n.value,meta:n.meta||{}};return t?n.set?r(e,{parent:function(){return t?{value:t.value,meta:t.meta,parent:t.parent}:t}}):t:r(e,{parent:$})}));function $(){return null}function _(n,r,t){if(t||2===arguments.length)for(var e,u=0,i=r.length;u<i;u++)!e&&u in r||(e||(e=Array.prototype.slice.call(r,0,u)),e[u]=r[u]);return n.concat(e||r)}function nn(n){for(var r=[],e=1;e<arguments.length;e++)r[e-1]=arguments[e];return t(n)?n.apply(void 0,r):n}function rn(n,r){var t;return null!==(t=nn(n))&&void 0!==t?t:r}function tn(n,r){throw Error(rn(r,n))}function en(){try{return t(Proxy)}catch(n){return!1}}function un(n,r){return n={pass:n},r&&(n.message=r),n}function on(n,r,t){for(var e=[],u=3;u<arguments.length;u++)e[u-3]=arguments[u];return B(n)||n&&B(n.pass)||tn("Incorrect return value for rule: "+JSON.stringify(n)),B(n)?un(n):un(n.pass,nn.apply(void 0,_([n.message,r,t],e)))}function an(n){function r(r,t,e){return function(){for(var u=[],i=0;i<arguments.length;i++)u[i]=arguments[i];if(!(i=on.apply(void 0,_([Z.run({value:n},(function(){return t.apply(void 0,_([n],u))})),e,n],u))).pass){if(!F(i.message))throw i.message;tn("enforce/"+e+" failed with "+JSON.stringify(n))}return r}}var t={};if(!en())return Y((function(n,e){t[n]=r(t,e,n)})),t;var e=new Proxy(t,{get:function(n,t){if(n=V[t])return r(e,n,t)}});return e}function sn(n,r){function t(n){e=!0,u=n}for(var e=!1,u=null,i=0;i<n.length;i++)if(r(n[i],t,i),e)return u}function fn(n){var r,t=[];return function n(e){return function(){for(var u=[],i=0;i<arguments.length;i++)u[i]=arguments[i];var o=V[e];t.push((function(n){return on.apply(void 0,_([o.apply(void 0,_([n],u)),e,n],u))}));var a={run:function(n){return rn(sn(t,(function(t,e){var u,i=Z.run({value:n},(function(){return t(n)}));i.pass||e(un(!!i.pass,null!==(u=nn(r,n,i.message))&&void 0!==u?u:i.message))})),un(!0))},test:function(n){return a.run(n).pass},message:function(n){return n&&(r=n),a}};return en()?a=new Proxy(a,{get:function(r,t){return V[t]?n(t):r[t]}}):(Y((function(r){a[r]=n(r)})),a)}}(n)}var cn,ln=(cn={context:function(){return Z.useX()},extend:function(n){r(V,n)}},en()?new Proxy(r(an,cn),{get:function(n,r){return r in n?n[r]:V[r]?fn(r):void 0}}):(Y((function(n){cn[n]=fn(n)})),cn));export{Z as ctx,ln as enforce};

package/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}