lakutata 2.0.82 → 2.0.83

package/src/lib/ioc/FunctionTokenizer.cjs

@@ -6,185 +6,185 @@ Object.defineProperty(exports, Symbol.toStringTag, {
 
 exports.TokenizerFlags = void 0;
 
-(function(e) {
-    e[e["None"] = 0] = "None";
-    e[e["Dumb"] = 1] = "Dumb";
+(function(t) {
+    t[t["None"] = 0] = "None";
+    t[t["Dumb"] = 1] = "Dumb";
 })(exports.TokenizerFlags || (exports.TokenizerFlags = {}));
 
-function createTokenizer(e) {
-    const t = e.length;
-    let n = 0;
-    let r = "EOF";
-    let i = "";
-    let s = exports.TokenizerFlags.None;
+function t(t) {
+    const r = t.length;
     let c = 0;
-    let o = 0;
+    let o = "EOF";
+    let s = "";
+    let a = exports.TokenizerFlags.None;
+    let f = 0;
+    let l = 0;
     return {
-        next,
-        done
+        next: h,
+        done: T
     };
-    function next(e = exports.TokenizerFlags.None) {
-        s = e;
-        advance();
-        return createToken();
+    function h(t = exports.TokenizerFlags.None) {
+        a = t;
+        F();
+        return z();
     }
-    function advance() {
-        i = "";
-        r = "EOF";
+    function F() {
+        s = "";
+        o = "EOF";
         while (true) {
-            if (n >= t) {
-                return r = "EOF";
+            if (c >= r) {
+                return o = "EOF";
             }
-            const i = e.charAt(n);
-            if (isWhiteSpace(i)) {
-                n++;
+            const n = t.charAt(c);
+            if (e(n)) {
+                c++;
                 continue;
             }
-            switch (i) {
+            switch (n) {
               case "(":
-                n++;
                 c++;
-                return r = i;
+                f++;
+                return o = n;
 
               case ")":
-                n++;
-                o++;
-                return r = i;
+                c++;
+                l++;
+                return o = n;
 
               case "*":
-                n++;
-                return r = i;
+                c++;
+                return o = n;
 
               case ",":
-                n++;
-                return r = i;
+                c++;
+                return o = n;
 
               case "=":
-                n++;
-                if ((s & exports.TokenizerFlags.Dumb) === 0) {
-                    skipExpression();
+                c++;
+                if ((a & exports.TokenizerFlags.Dumb) === 0) {
+                    g();
                 }
-                return r = i;
+                return o = n;
 
               case "/":
                 {
-                    n++;
-                    const t = e.charAt(n);
-                    if (t === "/") {
-                        skipUntil((e => e === "\n"), true);
-                        n++;
+                    c++;
+                    const e = t.charAt(c);
+                    if (e === "/") {
+                        p((t => t === "\n"), true);
+                        c++;
                     }
-                    if (t === "*") {
-                        skipUntil((t => {
-                            const r = e.charAt(n + 1);
-                            return t === "*" && r === "/";
+                    if (e === "*") {
+                        p((e => {
+                            const n = t.charAt(c + 1);
+                            return e === "*" && n === "/";
                         }), true);
-                        n++;
+                        c++;
                     }
                     continue;
                 }
 
               default:
-                if (isIdentifierStart(i)) {
-                    scanIdentifier();
-                    return r;
+                if (u(n)) {
+                    A();
+                    return o;
                 }
-                n++;
+                c++;
             }
         }
     }
-    function scanIdentifier() {
-        const t = e.charAt(n);
-        const s = ++n;
-        while (isIdentifierPart(e.charAt(n))) {
-            n++;
+    function A() {
+        const e = t.charAt(c);
+        const n = ++c;
+        while (i(t.charAt(c))) {
+            c++;
         }
-        i = "" + t + e.substring(s, n);
-        r = i === "function" || i === "class" ? i : "ident";
-        if (r !== "ident") {
-            i = "";
+        s = "" + e + t.substring(n, c);
+        o = s === "function" || s === "class" ? s : "ident";
+        if (o !== "ident") {
+            s = "";
         }
-        return i;
+        return s;
     }
-    function skipExpression() {
-        skipUntil((e => {
-            const t = c === o + 1;
-            if (e === "," && t) {
+    function g() {
+        p((t => {
+            const e = f === l + 1;
+            if (t === "," && e) {
                 return true;
             }
-            if (e === "(") {
-                c++;
+            if (t === "(") {
+                f++;
                 return false;
             }
-            if (e === ")") {
-                o++;
-                if (t) {
+            if (t === ")") {
+                l++;
+                if (e) {
                     return true;
                 }
             }
             return false;
         }));
     }
-    function skipUntil(t, r = false) {
-        while (n < e.length) {
-            const i = e.charAt(n);
-            if (t(i)) {
+    function p(r, u = false) {
+        while (c < t.length) {
+            const i = t.charAt(c);
+            if (r(i)) {
                 return;
             }
-            if (!r) {
-                if (isWhiteSpace(i)) {
-                    n++;
+            if (!u) {
+                if (e(i)) {
+                    c++;
                     continue;
                 }
-                if (isStringQuote(i)) {
-                    skipString();
+                if (n(i)) {
+                    x();
                     continue;
                 }
             }
-            n++;
+            c++;
         }
     }
-    function skipString() {
-        const t = e.charAt(n);
-        n++;
-        while (n < e.length) {
-            const r = e.charAt(n);
-            const i = e.charAt(n - 1);
-            if (r === t && i !== "\\") {
-                n++;
+    function x() {
+        const e = t.charAt(c);
+        c++;
+        while (c < t.length) {
+            const n = t.charAt(c);
+            const r = t.charAt(c - 1);
+            if (n === e && r !== "\\") {
+                c++;
                 return;
             }
-            if (t === "`") {
-                const t = e.charAt(n + 1);
-                if (t === "$") {
-                    const t = e.charAt(n + 2);
-                    if (t === "{") {
-                        n = n + 2;
-                        skipUntil((e => e === "}"));
+            if (e === "`") {
+                const e = t.charAt(c + 1);
+                if (e === "$") {
+                    const e = t.charAt(c + 2);
+                    if (e === "{") {
+                        c = c + 2;
+                        p((t => t === "}"));
                     }
                 }
             }
-            n++;
+            c++;
         }
     }
-    function createToken() {
-        if (i) {
+    function z() {
+        if (s) {
             return {
-                value: i,
-                type: r
+                value: s,
+                type: o
             };
         }
         return {
-            type: r
+            type: o
         };
     }
-    function done() {
-        return r === "EOF";
+    function T() {
+        return o === "EOF";
     }
 }
 
-function isWhiteSpace(e) {
-    switch (e) {
+function e(t) {
+    switch (t) {
       case "\r":
       case "\n":
       case " ":
@@ -193,8 +193,8 @@ function isWhiteSpace(e) {
     return false;
 }
 
-function isStringQuote(e) {
-    switch (e) {
+function n(t) {
+    switch (t) {
       case "'":
       case '"':
       case "`":
@@ -203,16 +203,16 @@ function isStringQuote(e) {
     return false;
 }
 
-const e = /^[_$a-zA-Z\xA0-\uFFFF]$/;
+const r = /^[_$a-zA-Z\xA0-\uFFFF]$/;
 
-const t = /^[._$a-zA-Z0-9\xA0-\uFFFF]$/;
+const c = /^[._$a-zA-Z0-9\xA0-\uFFFF]$/;
 
-function isIdentifierStart(t) {
-    return e.test(t);
+function u(t) {
+    return r.test(t);
 }
 
-function isIdentifierPart(e) {
-    return t.test(e);
+function i(t) {
+    return c.test(t);
 }
 
-exports.createTokenizer = createTokenizer;
+exports.createTokenizer = t;

package/src/lib/ioc/FunctionTokenizer.mjs

@@ -5,179 +5,179 @@ var t;
     t[t["Dumb"] = 1] = "Dumb";
 })(t || (t = {}));
 
-function createTokenizer(e) {
-    const n = e.length;
-    let r = 0;
-    let i = "EOF";
-    let c = "";
-    let s = t.None;
+function n(n) {
+    const c = n.length;
     let u = 0;
-    let a = 0;
+    let s = "EOF";
+    let o = "";
+    let a = t.None;
+    let h = 0;
+    let l = 0;
     return {
-        next,
-        done
+        next: A,
+        done: x
     };
-    function next(e = t.None) {
-        s = e;
-        advance();
-        return createToken();
+    function A(n = t.None) {
+        a = n;
+        F();
+        return g();
     }
-    function advance() {
-        c = "";
-        i = "EOF";
+    function F() {
+        o = "";
+        s = "EOF";
         while (true) {
-            if (r >= n) {
-                return i = "EOF";
+            if (u >= c) {
+                return s = "EOF";
             }
-            const c = e.charAt(r);
-            if (isWhiteSpace(c)) {
-                r++;
+            const r = n.charAt(u);
+            if (e(r)) {
+                u++;
                 continue;
             }
-            switch (c) {
+            switch (r) {
               case "(":
-                r++;
                 u++;
-                return i = c;
+                h++;
+                return s = r;
 
               case ")":
-                r++;
-                a++;
-                return i = c;
+                u++;
+                l++;
+                return s = r;
 
               case "*":
-                r++;
-                return i = c;
+                u++;
+                return s = r;
 
               case ",":
-                r++;
-                return i = c;
+                u++;
+                return s = r;
 
               case "=":
-                r++;
-                if ((s & t.Dumb) === 0) {
-                    skipExpression();
+                u++;
+                if ((a & t.Dumb) === 0) {
+                    $();
                 }
-                return i = c;
+                return s = r;
 
               case "/":
                 {
-                    r++;
-                    const t = e.charAt(r);
+                    u++;
+                    const t = n.charAt(u);
                     if (t === "/") {
-                        skipUntil((t => t === "\n"), true);
-                        r++;
+                        b((t => t === "\n"), true);
+                        u++;
                     }
                     if (t === "*") {
-                        skipUntil((t => {
-                            const n = e.charAt(r + 1);
-                            return t === "*" && n === "/";
+                        b((t => {
+                            const e = n.charAt(u + 1);
+                            return t === "*" && e === "/";
                         }), true);
-                        r++;
+                        u++;
                     }
                     continue;
                 }
 
               default:
-                if (isIdentifierStart(c)) {
-                    scanIdentifier();
-                    return i;
+                if (i(r)) {
+                    w();
+                    return s;
                 }
-                r++;
+                u++;
             }
         }
     }
-    function scanIdentifier() {
-        const t = e.charAt(r);
-        const n = ++r;
-        while (isIdentifierPart(e.charAt(r))) {
-            r++;
+    function w() {
+        const t = n.charAt(u);
+        const e = ++u;
+        while (f(n.charAt(u))) {
+            u++;
         }
-        c = "" + t + e.substring(n, r);
-        i = c === "function" || c === "class" ? c : "ident";
-        if (i !== "ident") {
-            c = "";
+        o = "" + t + n.substring(e, u);
+        s = o === "function" || o === "class" ? o : "ident";
+        if (s !== "ident") {
+            o = "";
         }
-        return c;
+        return o;
     }
-    function skipExpression() {
-        skipUntil((t => {
-            const e = u === a + 1;
-            if (t === "," && e) {
+    function $() {
+        b((t => {
+            const n = h === l + 1;
+            if (t === "," && n) {
                 return true;
             }
             if (t === "(") {
-                u++;
+                h++;
                 return false;
             }
             if (t === ")") {
-                a++;
-                if (e) {
+                l++;
+                if (n) {
                     return true;
                 }
             }
             return false;
         }));
     }
-    function skipUntil(t, n = false) {
-        while (r < e.length) {
-            const i = e.charAt(r);
+    function b(t, c = false) {
+        while (u < n.length) {
+            const i = n.charAt(u);
             if (t(i)) {
                 return;
             }
-            if (!n) {
-                if (isWhiteSpace(i)) {
-                    r++;
+            if (!c) {
+                if (e(i)) {
+                    u++;
                     continue;
                 }
-                if (isStringQuote(i)) {
-                    skipString();
+                if (r(i)) {
+                    d();
                     continue;
                 }
             }
-            r++;
+            u++;
         }
     }
-    function skipString() {
-        const t = e.charAt(r);
-        r++;
-        while (r < e.length) {
-            const n = e.charAt(r);
-            const i = e.charAt(r - 1);
-            if (n === t && i !== "\\") {
-                r++;
+    function d() {
+        const t = n.charAt(u);
+        u++;
+        while (u < n.length) {
+            const e = n.charAt(u);
+            const r = n.charAt(u - 1);
+            if (e === t && r !== "\\") {
+                u++;
                 return;
             }
             if (t === "`") {
-                const t = e.charAt(r + 1);
+                const t = n.charAt(u + 1);
                 if (t === "$") {
-                    const t = e.charAt(r + 2);
+                    const t = n.charAt(u + 2);
                     if (t === "{") {
-                        r = r + 2;
-                        skipUntil((t => t === "}"));
+                        u = u + 2;
+                        b((t => t === "}"));
                     }
                 }
             }
-            r++;
+            u++;
         }
     }
-    function createToken() {
-        if (c) {
+    function g() {
+        if (o) {
             return {
-                value: c,
-                type: i
+                value: o,
+                type: s
             };
         }
         return {
-            type: i
+            type: s
         };
     }
-    function done() {
-        return i === "EOF";
+    function x() {
+        return s === "EOF";
     }
 }
 
-function isWhiteSpace(t) {
+function e(t) {
     switch (t) {
       case "\r":
       case "\n":
@@ -187,7 +187,7 @@ function isWhiteSpace(t) {
     return false;
 }
 
-function isStringQuote(t) {
+function r(t) {
     switch (t) {
       case "'":
       case '"':
@@ -197,16 +197,16 @@ function isStringQuote(t) {
     return false;
 }
 
-const e = /^[_$a-zA-Z\xA0-\uFFFF]$/;
+const c = /^[_$a-zA-Z\xA0-\uFFFF]$/;
 
-const n = /^[._$a-zA-Z0-9\xA0-\uFFFF]$/;
+const u = /^[._$a-zA-Z0-9\xA0-\uFFFF]$/;
 
-function isIdentifierStart(t) {
-    return e.test(t);
+function i(t) {
+    return c.test(t);
 }
 
-function isIdentifierPart(t) {
-    return n.test(t);
+function f(t) {
+    return u.test(t);
 }
 
-export { t as TokenizerFlags, createTokenizer };
+export { t as TokenizerFlags, n as createTokenizer };

package/src/lib/ioc/Lifetime.cjs

@@ -12,12 +12,12 @@ const N = {
     SCOPED: "SCOPED"
 };
 
-function isLifetimeLonger(L, O) {
-    const E = L === "SINGLETON" ? "MODULE_SINGLETON" : L;
-    const T = O === "SINGLETON" ? "MODULE_SINGLETON" : O;
-    return E === N.APPLICATION_SINGLETON && T !== N.APPLICATION_SINGLETON || E === N.MODULE_SINGLETON && T === N.SCOPED || E === N.MODULE_SINGLETON && T === N.TRANSIENT || E === N.SCOPED && T === N.TRANSIENT;
+function O(O, E) {
+    const L = O === "SINGLETON" ? "MODULE_SINGLETON" : O;
+    const T = E === "SINGLETON" ? "MODULE_SINGLETON" : E;
+    return L === N.APPLICATION_SINGLETON && T !== N.APPLICATION_SINGLETON || L === N.MODULE_SINGLETON && T === N.SCOPED || L === N.MODULE_SINGLETON && T === N.TRANSIENT || L === N.SCOPED && T === N.TRANSIENT;
 }
 
 exports.Lifetime = N;
 
-exports.isLifetimeLonger = isLifetimeLonger;
+exports.isLifetimeLonger = O;

package/src/lib/ioc/Lifetime.mjs

@@ -6,10 +6,10 @@ const N = {
     SCOPED: "SCOPED"
 };
 
-function isLifetimeLonger(E, L) {
-    const O = E === "SINGLETON" ? "MODULE_SINGLETON" : E;
-    const I = L === "SINGLETON" ? "MODULE_SINGLETON" : L;
-    return O === N.APPLICATION_SINGLETON && I !== N.APPLICATION_SINGLETON || O === N.MODULE_SINGLETON && I === N.SCOPED || O === N.MODULE_SINGLETON && I === N.TRANSIENT || O === N.SCOPED && I === N.TRANSIENT;
+function E(E, O) {
+    const I = E === "SINGLETON" ? "MODULE_SINGLETON" : E;
+    const T = O === "SINGLETON" ? "MODULE_SINGLETON" : O;
+    return I === N.APPLICATION_SINGLETON && T !== N.APPLICATION_SINGLETON || I === N.MODULE_SINGLETON && T === N.SCOPED || I === N.MODULE_SINGLETON && T === N.TRANSIENT || I === N.SCOPED && T === N.TRANSIENT;
 }
 
-export { N as Lifetime, isLifetimeLonger };
+export { N as Lifetime, E as isLifetimeLonger };