@rindo/core 1.17.4 → 2.5.2

package/cli/index.js

@@ -1,500 +1,1237 @@
-const IS_NODE_ENV = !("undefined" == typeof global || "function" != typeof require || !global.process || "string" != typeof __filename || global.origin && "string" == typeof global.origin), dashToPascalCase = e => (e => e.toLowerCase())(e).split("-").map(e => e.charAt(0).toUpperCase() + e.slice(1)).join(""), isFunction = e => "function" == typeof e, isString = e => "string" == typeof e, hasError = e => null != e && 0 !== e.length && e.some(e => "error" === e.level && "runtime" !== e.type), shouldIgnoreError = e => e === TASK_CANCELED_MSG, TASK_CANCELED_MSG = "task canceled", normalizePath = e => {
- if ("string" != typeof e) throw new Error("invalid path to normalize");
- e = normalizeSlashes(e.trim());
- const t = pathComponents(e, getRootLength(e)), s = reducePathComponents(t), n = s[0], r = s[1], o = n + s.slice(1).join("/");
- return "" === o ? "." : "" === n && r && e.includes("/") && !r.startsWith(".") && !r.startsWith("@") ? "./" + o : o;
-}, normalizeSlashes = e => e.replace(backslashRegExp, "/"), backslashRegExp = /\\/g, reducePathComponents = e => {
- if (!Array.isArray(e) || 0 === e.length) return [];
- const t = [ e[0] ];
- for (let s = 1; s < e.length; s++) {
-  const n = e[s];
-  if (n && "." !== n) {
-   if (".." === n) if (t.length > 1) {
-    if (".." !== t[t.length - 1]) {
-     t.pop();
-     continue;
-    }
-   } else if (t[0]) continue;
-   t.push(n);
-  }
- }
- return t;
-}, getRootLength = e => {
- const t = getEncodedRootLength(e);
- return t < 0 ? ~t : t;
-}, getEncodedRootLength = e => {
- if (!e) return 0;
- const t = e.charCodeAt(0);
- if (47 === t || 92 === t) {
-  if (e.charCodeAt(1) !== t) return 1;
-  const s = e.indexOf(47 === t ? "/" : "\\", 2);
-  return s < 0 ? e.length : s + 1;
- }
- if (isVolumeCharacter(t) && 58 === e.charCodeAt(1)) {
-  const t = e.charCodeAt(2);
-  if (47 === t || 92 === t) return 3;
-  if (2 === e.length) return 2;
- }
- const s = e.indexOf("://");
- if (-1 !== s) {
-  const t = s + "://".length, n = e.indexOf("/", t);
-  if (-1 !== n) {
-   const r = e.slice(0, s), o = e.slice(t, n);
-   if ("file" === r && ("" === o || "localhost" === o) && isVolumeCharacter(e.charCodeAt(n + 1))) {
-    const t = getFileUrlVolumeSeparatorEnd(e, n + 2);
-    if (-1 !== t) {
-     if (47 === e.charCodeAt(t)) return ~(t + 1);
-     if (t === e.length) return ~t;
-    }
-   }
-   return ~(n + 1);
-  }
-  return ~e.length;
- }
- return 0;
-}, isVolumeCharacter = e => e >= 97 && e <= 122 || e >= 65 && e <= 90, getFileUrlVolumeSeparatorEnd = (e, t) => {
- const s = e.charCodeAt(t);
- if (58 === s) return t + 1;
- if (37 === s && 51 === e.charCodeAt(t + 1)) {
-  const s = e.charCodeAt(t + 2);
-  if (97 === s || 65 === s) return t + 3;
- }
- return -1;
-}, pathComponents = (e, t) => {
- const s = e.substring(0, t), n = e.substring(t).split("/"), r = n.length;
- return r > 0 && !n[r - 1] && n.pop(), [ s, ...n ];
-}, parseFlags = (e, t) => {
- const s = {
-  task: null,
-  args: [],
-  knownArgs: [],
-  unknownArgs: null
- };
- if (s.args = e.slice(), s.args.length > 0 && s.args[0] && !s.args[0].startsWith("-") && (s.task = s.args[0]), 
- parseArgs(s, s.args, s.knownArgs), t && "node" === t.name) {
-  const e = getNpmConfigEnvArgs(t);
-  parseArgs(s, e, s.knownArgs), e.forEach(e => {
-   s.args.includes(e) || s.args.push(e);
-  });
- }
- if (null != s.task) {
-  const e = s.args.indexOf(s.task);
-  e > -1 && s.args.splice(e, 1);
- }
- return s.unknownArgs = s.args.filter(e => !s.knownArgs.includes(e)), s;
-}, parseArgs = (e, t, s) => {
- ARG_OPTS.boolean.forEach(n => {
-  const r = ARG_OPTS.alias[n], o = configCase(n);
-  "boolean" != typeof e[o] && (e[o] = null), t.forEach(t => {
-   t === "--" + n || t === "--" + o ? (e[o] = !0, s.push(t)) : t === "--no-" + n || t === "--no" + dashToPascalCase(n) ? (e[o] = !1, 
-   s.push(t)) : r && t === "-" + r && (e[o] = !0, s.push(t));
-  });
- }), ARG_OPTS.string.forEach(n => {
-  const r = ARG_OPTS.alias[n], o = configCase(n);
-  "string" != typeof e[o] && (e[o] = null);
-  for (let i = 0; i < t.length; i++) {
-   const a = t[i];
-   if (a.startsWith(`--${n}=`)) {
-    const t = a.split("=");
-    t.shift(), e[o] = t.join("="), s.push(a);
-   } else if (a === "--" + n) e[o] = t[i + 1], s.push(a), s.push(t[i + 1]); else if (a === "--" + o) e[o] = t[i + 1], 
-   s.push(a), s.push(t[i + 1]); else if (a.startsWith(`--${o}=`)) {
-    const t = a.split("=");
-    t.shift(), e[o] = t.join("="), s.push(a);
-   } else if (r) if (a.startsWith(`-${r}=`)) {
-    const t = a.split("=");
-    t.shift(), e[o] = t.join("="), s.push(a);
-   } else a === "-" + r && (e[o] = t[i + 1], s.push(t[i + 1]));
-  }
- }), ARG_OPTS.number.forEach(n => {
-  const r = ARG_OPTS.alias[n], o = configCase(n);
-  "number" != typeof e[o] && (e[o] = null);
-  for (let i = 0; i < t.length; i++) {
-   const a = t[i];
-   if (a.startsWith(`--${n}=`)) {
-    const t = a.split("=");
-    t.shift(), e[o] = parseInt(t.join(""), 10), s.push(a);
-   } else if (a === "--" + n) e[o] = parseInt(t[i + 1], 10), s.push(t[i + 1]); else if (a.startsWith(`--${o}=`)) {
-    const t = a.split("=");
-    t.shift(), e[o] = parseInt(t.join(""), 10), s.push(a);
-   } else if (a === "--" + o) e[o] = parseInt(t[i + 1], 10), s.push(t[i + 1]); else if (r) if (a.startsWith(`-${r}=`)) {
-    const t = a.split("=");
-    t.shift(), e[o] = parseInt(t.join(""), 10), s.push(a);
-   } else a === "-" + r && (e[o] = parseInt(t[i + 1], 10), s.push(t[i + 1]));
+/*!
+ Rindo CLI v2.5.2 | MIT Licensed | https://rindojs.web.app
+ */
+const toLowerCase = (str) => str.toLowerCase();
+const dashToPascalCase = (str) => toLowerCase(str)
+    .split('-')
+    .map(segment => segment.charAt(0).toUpperCase() + segment.slice(1))
+    .join('');
+const isFunction = (v) => typeof v === 'function';
+const isString = (v) => typeof v === 'string';
+
+const buildError = (diagnostics) => {
+    const diagnostic = {
+        level: 'error',
+        type: 'build',
+        header: 'Build Error',
+        messageText: 'build error',
+        relFilePath: null,
+        absFilePath: null,
+        lines: [],
+    };
+    if (diagnostics) {
+        diagnostics.push(diagnostic);
+    }
+    return diagnostic;
+};
+const catchError = (diagnostics, err, msg) => {
+    const diagnostic = {
+        level: 'error',
+        type: 'build',
+        header: 'Build Error',
+        messageText: 'build error',
+        relFilePath: null,
+        absFilePath: null,
+        lines: [],
+    };
+    if (isString(msg)) {
+        diagnostic.messageText = msg;
+    }
+    else if (err != null) {
+        if (err.stack != null) {
+            diagnostic.messageText = err.stack.toString();
+        }
+        else {
+            if (err.message != null) {
+                diagnostic.messageText = err.message.toString();
+            }
+            else {
+                diagnostic.messageText = err.toString();
+            }
+        }
+    }
+    if (diagnostics != null && !shouldIgnoreError(diagnostic.messageText)) {
+        diagnostics.push(diagnostic);
+    }
+    return diagnostic;
+};
+const hasError = (diagnostics) => {
+    if (diagnostics == null || diagnostics.length === 0) {
+        return false;
+    }
+    return diagnostics.some(d => d.level === 'error' && d.type !== 'runtime');
+};
+const shouldIgnoreError = (msg) => {
+    return msg === TASK_CANCELED_MSG;
+};
+const TASK_CANCELED_MSG = `task canceled`;
+
+/**
+ * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+ * Forward-slash paths can be used in Windows as long as they're not
+ * extended-length paths and don't contain any non-ascii characters.
+ * This was created since the path methods in Node.js outputs \\ paths on Windows.
+ */
+const normalizePath = (path) => {
+    if (typeof path !== 'string') {
+        throw new Error(`invalid path to normalize`);
+    }
+    path = normalizeSlashes(path.trim());
+    const components = pathComponents(path, getRootLength(path));
+    const reducedComponents = reducePathComponents(components);
+    const rootPart = reducedComponents[0];
+    const secondPart = reducedComponents[1];
+    const normalized = rootPart + reducedComponents.slice(1).join('/');
+    if (normalized === '') {
+        return '.';
+    }
+    if (rootPart === '' &&
+        secondPart &&
+        path.includes('/') &&
+        !secondPart.startsWith('.') &&
+        !secondPart.startsWith('@')) {
+        return './' + normalized;
+    }
+    return normalized;
+};
+const normalizeSlashes = (path) => path.replace(backslashRegExp, '/');
+const altDirectorySeparator = '\\';
+const urlSchemeSeparator = '://';
+const backslashRegExp = /\\/g;
+const reducePathComponents = (components) => {
+    if (!Array.isArray(components) || components.length === 0) {
+        return [];
+    }
+    const reduced = [components[0]];
+    for (let i = 1; i < components.length; i++) {
+        const component = components[i];
+        if (!component)
+            continue;
+        if (component === '.')
+            continue;
+        if (component === '..') {
+            if (reduced.length > 1) {
+                if (reduced[reduced.length - 1] !== '..') {
+                    reduced.pop();
+                    continue;
+                }
+            }
+            else if (reduced[0])
+                continue;
+        }
+        reduced.push(component);
+    }
+    return reduced;
+};
+const getRootLength = (path) => {
+    const rootLength = getEncodedRootLength(path);
+    return rootLength < 0 ? ~rootLength : rootLength;
+};
+const getEncodedRootLength = (path) => {
+    if (!path)
+        return 0;
+    const ch0 = path.charCodeAt(0);
+    // POSIX or UNC
+    if (ch0 === 47 /* slash */ || ch0 === 92 /* backslash */) {
+        if (path.charCodeAt(1) !== ch0)
+            return 1; // POSIX: "/" (or non-normalized "\")
+        const p1 = path.indexOf(ch0 === 47 /* slash */ ? '/' : altDirectorySeparator, 2);
+        if (p1 < 0)
+            return path.length; // UNC: "//server" or "\\server"
+        return p1 + 1; // UNC: "//server/" or "\\server\"
+    }
+    // DOS
+    if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* colon */) {
+        const ch2 = path.charCodeAt(2);
+        if (ch2 === 47 /* slash */ || ch2 === 92 /* backslash */)
+            return 3; // DOS: "c:/" or "c:\"
+        if (path.length === 2)
+            return 2; // DOS: "c:" (but not "c:d")
+    }
+    // URL
+    const schemeEnd = path.indexOf(urlSchemeSeparator);
+    if (schemeEnd !== -1) {
+        const authorityStart = schemeEnd + urlSchemeSeparator.length;
+        const authorityEnd = path.indexOf('/', authorityStart);
+        if (authorityEnd !== -1) {
+            // URL: "file:///", "file://server/", "file://server/path"
+            // For local "file" URLs, include the leading DOS volume (if present).
+            // Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a
+            // special case interpreted as "the machine from which the URL is being interpreted".
+            const scheme = path.slice(0, schemeEnd);
+            const authority = path.slice(authorityStart, authorityEnd);
+            if (scheme === 'file' &&
+                (authority === '' || authority === 'localhost') &&
+                isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
+                const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
+                if (volumeSeparatorEnd !== -1) {
+                    if (path.charCodeAt(volumeSeparatorEnd) === 47 /* slash */) {
+                        // URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
+                        return ~(volumeSeparatorEnd + 1);
+                    }
+                    if (volumeSeparatorEnd === path.length) {
+                        // URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a"
+                        // but not "file:///c:d" or "file:///c%3ad"
+                        return ~volumeSeparatorEnd;
+                    }
+                }
+            }
+            return ~(authorityEnd + 1); // URL: "file://server/", "http://server/"
+        }
+        return ~path.length; // URL: "file://server", "http://server"
+    }
+    // relative
+    return 0;
+};
+const isVolumeCharacter = (charCode) => (charCode >= 97 /* a */ && charCode <= 122 /* z */) ||
+    (charCode >= 65 /* A */ && charCode <= 90 /* Z */);
+const getFileUrlVolumeSeparatorEnd = (url, start) => {
+    const ch0 = url.charCodeAt(start);
+    if (ch0 === 58 /* colon */)
+        return start + 1;
+    if (ch0 === 37 /* percent */ && url.charCodeAt(start + 1) === 51 /* _3 */) {
+        const ch2 = url.charCodeAt(start + 2);
+        if (ch2 === 97 /* a */ || ch2 === 65 /* A */)
+            return start + 3;
+    }
+    return -1;
+};
+const pathComponents = (path, rootLength) => {
+    const root = path.substring(0, rootLength);
+    const rest = path.substring(rootLength).split('/');
+    const restLen = rest.length;
+    if (restLen > 0 && !rest[restLen - 1]) {
+        rest.pop();
+    }
+    return [root, ...rest];
+};
+
+const validateComponentTag = (tag) => {
+    if (tag !== tag.trim()) {
+        return `Tag can not contain white spaces`;
+    }
+    if (tag !== tag.toLowerCase()) {
+        return `Tag can not contain upper case characters`;
+    }
+    if (typeof tag !== 'string') {
+        return `Tag "${tag}" must be a string type`;
+    }
+    if (tag.length === 0) {
+        return `Received empty tag value`;
+    }
+    if (tag.indexOf(' ') > -1) {
+        return `"${tag}" tag cannot contain a space`;
+    }
+    if (tag.indexOf(',') > -1) {
+        return `"${tag}" tag cannot be used for multiple tags`;
+    }
+    const invalidChars = tag.replace(/\w|-/g, '');
+    if (invalidChars !== '') {
+        return `"${tag}" tag contains invalid characters: ${invalidChars}`;
+    }
+    if (tag.indexOf('-') === -1) {
+        return `"${tag}" tag must contain a dash (-) to work as a valid web component`;
+    }
+    if (tag.indexOf('--') > -1) {
+        return `"${tag}" tag cannot contain multiple dashes (--) next to each other`;
+    }
+    if (tag.indexOf('-') === 0) {
+        return `"${tag}" tag cannot start with a dash (-)`;
+    }
+    if (tag.lastIndexOf('-') === tag.length - 1) {
+        return `"${tag}" tag cannot end with a dash (-)`;
+    }
+    return undefined;
+};
+
+const parseFlags = (args, sys) => {
+    const flags = {
+        task: null,
+        args: [],
+        knownArgs: [],
+        unknownArgs: null,
+    };
+    // cmd line has more priority over npm scripts cmd
+    flags.args = args.slice();
+    if (flags.args.length > 0 && flags.args[0] && !flags.args[0].startsWith('-')) {
+        flags.task = flags.args[0];
+    }
+    parseArgs(flags, flags.args, flags.knownArgs);
+    if (sys && sys.name === 'node') {
+        const envArgs = getNpmConfigEnvArgs(sys);
+        parseArgs(flags, envArgs, flags.knownArgs);
+        envArgs.forEach(envArg => {
+            if (!flags.args.includes(envArg)) {
+                flags.args.push(envArg);
+            }
+        });
+    }
+    if (flags.task != null) {
+        const i = flags.args.indexOf(flags.task);
+        if (i > -1) {
+            flags.args.splice(i, 1);
+        }
+    }
+    flags.unknownArgs = flags.args.filter((arg) => {
+        return !flags.knownArgs.includes(arg);
+    });
+    return flags;
+};
+const parseArgs = (flags, args, knownArgs) => {
+    ARG_OPTS.boolean.forEach(booleanName => {
+        const alias = ARG_OPTS.alias[booleanName];
+        const flagKey = configCase(booleanName);
+        if (typeof flags[flagKey] !== 'boolean') {
+            flags[flagKey] = null;
+        }
+        args.forEach(cmdArg => {
+            if (cmdArg === `--${booleanName}`) {
+                flags[flagKey] = true;
+                knownArgs.push(cmdArg);
+            }
+            else if (cmdArg === `--${flagKey}`) {
+                flags[flagKey] = true;
+                knownArgs.push(cmdArg);
+            }
+            else if (cmdArg === `--no-${booleanName}`) {
+                flags[flagKey] = false;
+                knownArgs.push(cmdArg);
+            }
+            else if (cmdArg === `--no${dashToPascalCase(booleanName)}`) {
+                flags[flagKey] = false;
+                knownArgs.push(cmdArg);
+            }
+            else if (alias && cmdArg === `-${alias}`) {
+                flags[flagKey] = true;
+                knownArgs.push(cmdArg);
+            }
+        });
+    });
+    ARG_OPTS.string.forEach(stringName => {
+        const alias = ARG_OPTS.alias[stringName];
+        const flagKey = configCase(stringName);
+        if (typeof flags[flagKey] !== 'string') {
+            flags[flagKey] = null;
+        }
+        for (let i = 0; i < args.length; i++) {
+            const cmdArg = args[i];
+            if (cmdArg.startsWith(`--${stringName}=`)) {
+                const values = cmdArg.split('=');
+                values.shift();
+                flags[flagKey] = values.join('=');
+                knownArgs.push(cmdArg);
+            }
+            else if (cmdArg === `--${stringName}`) {
+                flags[flagKey] = args[i + 1];
+                knownArgs.push(cmdArg);
+                knownArgs.push(args[i + 1]);
+            }
+            else if (cmdArg === `--${flagKey}`) {
+                flags[flagKey] = args[i + 1];
+                knownArgs.push(cmdArg);
+                knownArgs.push(args[i + 1]);
+            }
+            else if (cmdArg.startsWith(`--${flagKey}=`)) {
+                const values = cmdArg.split('=');
+                values.shift();
+                flags[flagKey] = values.join('=');
+                knownArgs.push(cmdArg);
+            }
+            else if (alias) {
+                if (cmdArg.startsWith(`-${alias}=`)) {
+                    const values = cmdArg.split('=');
+                    values.shift();
+                    flags[flagKey] = values.join('=');
+                    knownArgs.push(cmdArg);
+                }
+                else if (cmdArg === `-${alias}`) {
+                    flags[flagKey] = args[i + 1];
+                    knownArgs.push(args[i + 1]);
+                }
+            }
+        }
+    });
+    ARG_OPTS.number.forEach(numberName => {
+        const alias = ARG_OPTS.alias[numberName];
+        const flagKey = configCase(numberName);
+        if (typeof flags[flagKey] !== 'number') {
+            flags[flagKey] = null;
+        }
+        for (let i = 0; i < args.length; i++) {
+            const cmdArg = args[i];
+            if (cmdArg.startsWith(`--${numberName}=`)) {
+                const values = cmdArg.split('=');
+                values.shift();
+                flags[flagKey] = parseInt(values.join(''), 10);
+                knownArgs.push(cmdArg);
+            }
+            else if (cmdArg === `--${numberName}`) {
+                flags[flagKey] = parseInt(args[i + 1], 10);
+                knownArgs.push(args[i + 1]);
+            }
+            else if (cmdArg.startsWith(`--${flagKey}=`)) {
+                const values = cmdArg.split('=');
+                values.shift();
+                flags[flagKey] = parseInt(values.join(''), 10);
+                knownArgs.push(cmdArg);
+            }
+            else if (cmdArg === `--${flagKey}`) {
+                flags[flagKey] = parseInt(args[i + 1], 10);
+                knownArgs.push(args[i + 1]);
+            }
+            else if (alias) {
+                if (cmdArg.startsWith(`-${alias}=`)) {
+                    const values = cmdArg.split('=');
+                    values.shift();
+                    flags[flagKey] = parseInt(values.join(''), 10);
+                    knownArgs.push(cmdArg);
+                }
+                else if (cmdArg === `-${alias}`) {
+                    flags[flagKey] = parseInt(args[i + 1], 10);
+                    knownArgs.push(args[i + 1]);
+                }
+            }
+        }
+    });
+};
+const configCase = (prop) => {
+    prop = dashToPascalCase(prop);
+    return prop.charAt(0).toLowerCase() + prop.substr(1);
+};
+const ARG_OPTS = {
+    boolean: [
+        'build',
+        'cache',
+        'check-version',
+        'ci',
+        'compare',
+        'debug',
+        'dev',
+        'devtools',
+        'docs',
+        'e2e',
+        'es5',
+        'esm',
+        'headless',
+        'help',
+        'log',
+        'open',
+        'prerender',
+        'prerender-external',
+        'prod',
+        'profile',
+        'service-worker',
+        'screenshot',
+        'serve',
+        'skip-node-check',
+        'spec',
+        'ssr',
+        'stats',
+        'update-screenshot',
+        'verbose',
+        'version',
+        'watch',
+    ],
+    number: ['max-workers', 'port'],
+    string: ['address', 'config', 'docs-json', 'emulate', 'log-level', 'root', 'screenshot-connector'],
+    alias: {
+        config: 'c',
+        help: 'h',
+        port: 'p',
+        version: 'v',
+    },
+};
+const getNpmConfigEnvArgs = (sys) => {
+    // process.env.npm_config_argv
+    // {"remain":["4444"],"cooked":["run","serve","--port","4444"],"original":["run","serve","--port","4444"]}
+    let args = [];
+    try {
+        const npmConfigArgs = sys.getEnvironmentVar('npm_config_argv');
+        if (npmConfigArgs) {
+            args = JSON.parse(npmConfigArgs).original;
+            if (args[0] === 'run') {
+                args = args.slice(2);
+            }
+        }
+    }
+    catch (e) { }
+    return args;
+};
+
+const dependencies = [
+	{
+		name: "@rindo/core",
+		version: "2.5.2",
+		main: "compiler/rindo.js",
+		resources: [
+			"package.json",
+			"compiler/lib.d.ts",
+			"compiler/lib.dom.d.ts",
+			"compiler/lib.dom.iterable.d.ts",
+			"compiler/lib.es2015.collection.d.ts",
+			"compiler/lib.es2015.core.d.ts",
+			"compiler/lib.es2015.d.ts",
+			"compiler/lib.es2015.generator.d.ts",
+			"compiler/lib.es2015.iterable.d.ts",
+			"compiler/lib.es2015.promise.d.ts",
+			"compiler/lib.es2015.proxy.d.ts",
+			"compiler/lib.es2015.reflect.d.ts",
+			"compiler/lib.es2015.symbol.d.ts",
+			"compiler/lib.es2015.symbol.wellknown.d.ts",
+			"compiler/lib.es2016.array.include.d.ts",
+			"compiler/lib.es2016.d.ts",
+			"compiler/lib.es2016.full.d.ts",
+			"compiler/lib.es2017.d.ts",
+			"compiler/lib.es2017.full.d.ts",
+			"compiler/lib.es2017.intl.d.ts",
+			"compiler/lib.es2017.object.d.ts",
+			"compiler/lib.es2017.sharedmemory.d.ts",
+			"compiler/lib.es2017.string.d.ts",
+			"compiler/lib.es2017.typedarrays.d.ts",
+			"compiler/lib.es2018.asyncgenerator.d.ts",
+			"compiler/lib.es2018.asynciterable.d.ts",
+			"compiler/lib.es2018.d.ts",
+			"compiler/lib.es2018.full.d.ts",
+			"compiler/lib.es2018.intl.d.ts",
+			"compiler/lib.es2018.promise.d.ts",
+			"compiler/lib.es2018.regexp.d.ts",
+			"compiler/lib.es2019.array.d.ts",
+			"compiler/lib.es2019.d.ts",
+			"compiler/lib.es2019.full.d.ts",
+			"compiler/lib.es2019.object.d.ts",
+			"compiler/lib.es2019.string.d.ts",
+			"compiler/lib.es2019.symbol.d.ts",
+			"compiler/lib.es2020.bigint.d.ts",
+			"compiler/lib.es2020.d.ts",
+			"compiler/lib.es2020.full.d.ts",
+			"compiler/lib.es2020.intl.d.ts",
+			"compiler/lib.es2020.promise.d.ts",
+			"compiler/lib.es2020.sharedmemory.d.ts",
+			"compiler/lib.es2020.string.d.ts",
+			"compiler/lib.es2020.symbol.wellknown.d.ts",
+			"compiler/lib.es5.d.ts",
+			"compiler/lib.es6.d.ts",
+			"compiler/lib.esnext.d.ts",
+			"compiler/lib.esnext.full.d.ts",
+			"compiler/lib.esnext.intl.d.ts",
+			"compiler/lib.esnext.promise.d.ts",
+			"compiler/lib.esnext.string.d.ts",
+			"compiler/lib.esnext.weakref.d.ts",
+			"compiler/lib.scripthost.d.ts",
+			"compiler/lib.webworker.d.ts",
+			"compiler/lib.webworker.importscripts.d.ts",
+			"compiler/lib.webworker.iterable.d.ts",
+			"internal/index.d.ts",
+			"internal/index.js",
+			"internal/package.json",
+			"internal/rindo-ext-modules.d.ts",
+			"internal/rindo-private.d.ts",
+			"internal/rindo-public-compiler.d.ts",
+			"internal/rindo-public-docs.d.ts",
+			"internal/rindo-public-runtime.d.ts",
+			"mock-doc/index.js",
+			"mock-doc/package.json",
+			"internal/client/css-shim.js",
+			"internal/client/dom.js",
+			"internal/client/index.js",
+			"internal/client/package.json",
+			"internal/client/patch-browser.js",
+			"internal/client/patch-esm.js",
+			"internal/client/shadow-css.js",
+			"internal/hydrate/index.js",
+			"internal/hydrate/package.json",
+			"internal/hydrate/runner.js",
+			"internal/hydrate/shadow-css.js",
+			"internal/rindo-core/index.d.ts",
+			"internal/rindo-core/index.js"
+		]
+	},
+	{
+		name: "rollup",
+		version: "2.42.3",
+		main: "dist/es/rollup.browser.js"
+	},
+	{
+		name: "terser",
+		version: "5.6.1",
+		main: "dist/bundle.min.js"
+	},
+	{
+		name: "typescript",
+		version: "4.2.3",
+		main: "lib/typescript.js"
+	}
+];
+
+const findConfig = async (opts) => {
+    const sys = opts.sys;
+    const cwd = sys.getCurrentDirectory();
+    const results = {
+        configPath: null,
+        rootDir: normalizePath(cwd),
+        diagnostics: [],
+    };
+    let configPath = opts.configPath;
+    if (isString(configPath)) {
+        if (!sys.platformPath.isAbsolute(configPath)) {
+            // passed in a custom rindo config location
+            // but it's relative, so prefix the cwd
+            configPath = normalizePath(sys.platformPath.join(cwd, configPath));
+        }
+        else {
+            // config path already an absolute path, we're good here
+            configPath = normalizePath(opts.configPath);
+        }
+    }
+    else {
+        // nothing was passed in, use the current working directory
+        configPath = results.rootDir;
+    }
+    const stat = await sys.stat(configPath);
+    if (stat.error) {
+        const diagnostic = buildError(results.diagnostics);
+        diagnostic.absFilePath = configPath;
+        diagnostic.header = `Invalid config path`;
+        diagnostic.messageText = `Config path "${configPath}" not found`;
+        return results;
+    }
+    if (stat.isFile) {
+        results.configPath = configPath;
+        results.rootDir = sys.platformPath.dirname(configPath);
+    }
+    else if (stat.isDirectory) {
+        // this is only a directory, so let's make some assumptions
+        for (const configName of ['rindo.config.ts', 'rindo.config.js']) {
+            const testConfigFilePath = sys.platformPath.join(configPath, configName);
+            const stat = await sys.stat(testConfigFilePath);
+            if (stat.isFile) {
+                results.configPath = testConfigFilePath;
+                results.rootDir = sys.platformPath.dirname(testConfigFilePath);
+                break;
+            }
+        }
+    }
+    return results;
+};
+
+const loadCoreCompiler = async (sys) => {
+    await sys.dynamicImport(sys.getCompilerExecutingPath());
+    return globalThis.rindo;
+};
+
+const startupLog = (logger, task) => {
+    if (task === 'info' || task === 'serve' || task === 'version') {
+        return;
+    }
+    logger.info(logger.cyan(`@rindo/core`));
+};
+const startupLogVersion = (logger, task, coreCompiler) => {
+    if (task === 'info' || task === 'serve' || task === 'version') {
+        return;
+    }
+    const isDevBuild = coreCompiler.version.includes('-dev.');
+    let startupMsg;
+    if (isDevBuild) {
+        startupMsg = logger.yellow('[LOCAL DEV]');
+    }
+    else {
+        startupMsg = logger.cyan(`v${coreCompiler.version}`);
+    }
+    startupMsg += logger.emoji(' ' + coreCompiler.vermoji);
+    logger.info(startupMsg);
+};
+const loadedCompilerLog = (sys, logger, flags, coreCompiler) => {
+    const sysDetails = sys.details;
+    const runtimeInfo = `${sys.name} ${sys.version}`;
+    const platformInfo = `${sysDetails.platform}, ${sysDetails.cpuModel}`;
+    const statsInfo = `cpus: ${sys.hardwareConcurrency}, freemem: ${Math.round(sysDetails.freemem() / 1000000)}MB, totalmem: ${Math.round(sysDetails.totalmem / 1000000)}MB`;
+    if (logger.getLevel() === 'debug') {
+        logger.debug(runtimeInfo);
+        logger.debug(platformInfo);
+        logger.debug(statsInfo);
+        logger.debug(`compiler: ${sys.getCompilerExecutingPath()}`);
+        logger.debug(`build: ${coreCompiler.buildId}`);
+    }
+    else if (flags.ci) {
+        logger.info(runtimeInfo);
+        logger.info(platformInfo);
+        logger.info(statsInfo);
+    }
+};
+const startupCompilerLog = (coreCompiler, config) => {
+    if (config.suppressLogs === true) {
+        return;
+    }
+    const { logger } = config;
+    const isDebug = logger.getLevel() === 'debug';
+    const isPrerelease = coreCompiler.version.includes('-');
+    const isDevBuild = coreCompiler.version.includes('-dev.');
+    if (isPrerelease && !isDevBuild) {
+        logger.warn(logger.yellow(`This is a prerelease build, undocumented changes might happen at any time. Technical support is not available for prereleases, but any assistance testing is appreciated.`));
+    }
+    if (config.devMode && !isDebug) {
+        if (config.buildEs5) {
+            logger.warn(`Generating ES5 during development is a very task expensive, initial and incremental builds will be much slower. Drop the '--es5' flag and use a modern browser for development.`);
+        }
+        if (!config.enableCache) {
+            logger.warn(`Disabling cache during development will slow down incremental builds.`);
+        }
+    }
+};
+
+const taskPrerender = async (coreCompiler, config) => {
+    startupCompilerLog(coreCompiler, config);
+    const hydrateAppFilePath = config.flags.unknownArgs[0];
+    if (typeof hydrateAppFilePath !== 'string') {
+        config.logger.error(`Missing hydrate app script path`);
+        return config.sys.exit(1);
+    }
+    const srcIndexHtmlPath = config.srcIndexHtml;
+    const diagnostics = await runPrerenderTask(coreCompiler, config, hydrateAppFilePath, null, srcIndexHtmlPath);
+    config.logger.printDiagnostics(diagnostics);
+    if (diagnostics.some(d => d.level === 'error')) {
+        return config.sys.exit(1);
+    }
+};
+const runPrerenderTask = async (coreCompiler, config, hydrateAppFilePath, componentGraph, srcIndexHtmlPath) => {
+    const diagnostics = [];
+    try {
+        const prerenderer = await coreCompiler.createPrerenderer(config);
+        const results = await prerenderer.start({
+            hydrateAppFilePath,
+            componentGraph,
+            srcIndexHtmlPath,
+        });
+        diagnostics.push(...results.diagnostics);
+    }
+    catch (e) {
+        catchError(diagnostics, e);
+    }
+    return diagnostics;
+};
+
+const startCheckVersion = async (config, currentVersion) => {
+    if (config.devMode && !config.flags.ci && !currentVersion.includes('-dev.') && isFunction(config.sys.checkVersion)) {
+        return config.sys.checkVersion(config.logger, currentVersion);
+    }
+    return null;
+};
+const printCheckVersionResults = async (versionChecker) => {
+    if (versionChecker) {
+        const checkVersionResults = await versionChecker;
+        if (isFunction(checkVersionResults)) {
+            checkVersionResults();
+        }
+    }
+};
+
+const taskWatch = async (coreCompiler, config) => {
+    let devServer = null;
+    let exitCode = 0;
+    try {
+        startupCompilerLog(coreCompiler, config);
+        const versionChecker = startCheckVersion(config, coreCompiler.version);
+        const compiler = await coreCompiler.createCompiler(config);
+        const watcher = await compiler.createWatcher();
+        if (config.flags.serve) {
+            const devServerPath = config.sys.getDevServerExecutingPath();
+            const { start } = await config.sys.dynamicImport(devServerPath);
+            devServer = await start(config.devServer, config.logger, watcher);
+        }
+        config.sys.onProcessInterrupt(() => {
+            config.logger.debug(`close watch`);
+            compiler && compiler.destroy();
+        });
+        const rmVersionCheckerLog = watcher.on('buildFinish', async () => {
+            // log the version check one time
+            rmVersionCheckerLog();
+            printCheckVersionResults(versionChecker);
+        });
+        if (devServer) {
+            const rmDevServerLog = watcher.on('buildFinish', () => {
+                // log the dev server url one time
+                rmDevServerLog();
+                config.logger.info(`${config.logger.cyan(devServer.browserUrl)}\n`);
+            });
+        }
+        const closeResults = await watcher.start();
+        if (closeResults.exitCode > 0) {
+            exitCode = closeResults.exitCode;
+        }
+    }
+    catch (e) {
+        exitCode = 1;
+        config.logger.error(e);
+    }
+    if (devServer) {
+        await devServer.close();
+    }
+    if (exitCode > 0) {
+        return config.sys.exit(exitCode);
+    }
+};
+
+const taskBuild = async (coreCompiler, config) => {
+    if (config.flags.watch) {
+        // watch build
+        await taskWatch(coreCompiler, config);
+        return;
+    }
+    // one-time build
+    let exitCode = 0;
+    try {
+        startupCompilerLog(coreCompiler, config);
+        const versionChecker = startCheckVersion(config, coreCompiler.version);
+        const compiler = await coreCompiler.createCompiler(config);
+        const results = await compiler.build();
+        await compiler.destroy();
+        if (results.hasError) {
+            exitCode = 1;
+        }
+        else if (config.flags.prerender) {
+            const prerenderDiagnostics = await runPrerenderTask(coreCompiler, config, results.hydrateAppFilePath, results.componentGraph, null);
+            config.logger.printDiagnostics(prerenderDiagnostics);
+            if (prerenderDiagnostics.some(d => d.level === 'error')) {
+                exitCode = 1;
+            }
+        }
+        await printCheckVersionResults(versionChecker);
+    }
+    catch (e) {
+        exitCode = 1;
+        config.logger.error(e);
+    }
+    if (exitCode > 0) {
+        return config.sys.exit(exitCode);
+    }
+};
+
+const isOutputTargetDocs = (o) => o.type === DOCS_README || o.type === DOCS_JSON || o.type === DOCS_CUSTOM || o.type === DOCS_VSCODE;
+const DOCS_CUSTOM = 'docs-custom';
+const DOCS_JSON = `docs-json`;
+const DOCS_README = `docs-readme`;
+const DOCS_VSCODE = `docs-vscode`;
+
+const taskDocs = async (coreCompiler, config) => {
+    config.devServer = null;
+    config.outputTargets = config.outputTargets.filter(isOutputTargetDocs);
+    config.devMode = true;
+    startupCompilerLog(coreCompiler, config);
+    const compiler = await coreCompiler.createCompiler(config);
+    await compiler.build();
+    await compiler.destroy();
+};
+
+const IS_DENO_ENV = typeof Deno !== 'undefined';
+const IS_NODE_ENV = !IS_DENO_ENV &&
+    typeof global !== 'undefined' &&
+    typeof require === 'function' &&
+    !!global.process &&
+    typeof __filename === 'string' &&
+    (!global.origin || typeof global.origin !== 'string');
+
+/**
+ * Task to generate component boilerplate.
+ */
+const taskGenerate = async (coreCompiler, config) => {
+    if (!IS_NODE_ENV) {
+        config.logger.error(`"generate" command is currently only implemented for a NodeJS environment`);
+        return config.sys.exit(1);
+    }
+    const path = coreCompiler.path;
+    if (!config.configPath) {
+        config.logger.error('Please run this command in your root directory (i. e. the one containing rindo.config.ts).');
+        return config.sys.exit(1);
+    }
+    const absoluteSrcDir = config.srcDir;
+    if (!absoluteSrcDir) {
+        config.logger.error(`Rindo's srcDir was not specified.`);
+        return config.sys.exit(1);
+    }
+    const { prompt } = await import('../sys/node/prompts.js');
+    const input = config.flags.unknownArgs.find(arg => !arg.startsWith('-')) ||
+        (await prompt({ name: 'tagName', type: 'text', message: 'Component tag name (dash-case):' })).tagName;
+    const { dir, base: componentName } = path.parse(input);
+    const tagError = validateComponentTag(componentName);
+    if (tagError) {
+        config.logger.error(tagError);
+        return config.sys.exit(1);
+    }
+    const extensionsToGenerate = ['tsx', ...(await chooseFilesToGenerate())];
+    const testFolder = extensionsToGenerate.some(isTest) ? 'test' : '';
+    const outDir = path.join(absoluteSrcDir, 'components', dir, componentName);
+    await config.sys.createDir(path.join(outDir, testFolder), { recursive: true });
+    const writtenFiles = await Promise.all(extensionsToGenerate.map(extension => writeFileByExtension(coreCompiler, config, outDir, componentName, extension, extensionsToGenerate.includes('css')))).catch(error => config.logger.error(error));
+    if (!writtenFiles) {
+        return config.sys.exit(1);
+    }
+    console.log();
+    console.log(`${config.logger.gray('$')} rindo generate ${input}`);
+    console.log();
+    console.log(config.logger.bold('The following files have been generated:'));
+    const absoluteRootDir = config.rootDir;
+    writtenFiles.map(file => console.log(`  - ${path.relative(absoluteRootDir, file)}`));
+};
+/**
+ * Show a checkbox prompt to select the files to be generated.
+ */
+const chooseFilesToGenerate = async () => {
+    const { prompt } = await import('../sys/node/prompts.js');
+    return (await prompt({
+        name: 'filesToGenerate',
+        type: 'multiselect',
+        message: 'Which additional files do you want to generate?',
+        choices: [
+            { value: 'css', title: 'Stylesheet (.css)', selected: true },
+            { value: 'spec.tsx', title: 'Spec Test  (.spec.tsx)', selected: true },
+            { value: 'e2e.ts', title: 'E2E Test (.e2e.ts)', selected: true },
+        ],
+    })).filesToGenerate;
+};
+/**
+ * Get a file's boilerplate by its extension and write it to disk.
+ */
+const writeFileByExtension = async (coreCompiler, config, path, name, extension, withCss) => {
+    if (isTest(extension)) {
+        path = coreCompiler.path.join(path, 'test');
+    }
+    const outFile = coreCompiler.path.join(path, `${name}.${extension}`);
+    const boilerplate = getBoilerplateByExtension(name, extension, withCss);
+    await config.sys.writeFile(outFile, boilerplate);
+    return outFile;
+};
+const isTest = (extension) => {
+    return extension === 'e2e.ts' || extension === 'spec.tsx';
+};
+/**
+ * Get the boilerplate for a file by its extension.
+ */
+const getBoilerplateByExtension = (tagName, extension, withCss) => {
+    switch (extension) {
+        case 'tsx':
+            return getComponentBoilerplate(tagName, withCss);
+        case 'css':
+            return getStyleUrlBoilerplate();
+        case 'spec.tsx':
+            return getSpecTestBoilerplate(tagName);
+        case 'e2e.ts':
+            return getE2eTestBoilerplate(tagName);
+        default:
+            throw new Error(`Unkown extension "${extension}".`);
+    }
+};
+/**
+ * Get the boilerplate for a component.
+ */
+const getComponentBoilerplate = (tagName, hasStyle) => {
+    const decorator = [`{`];
+    decorator.push(`  tag: '${tagName}',`);
+    if (hasStyle) {
+        decorator.push(`  styleUrl: '${tagName}.css',`);
+    }
+    decorator.push(`  shadow: true,`);
+    decorator.push(`}`);
+    return `import { Component, Host, h } from '@rindo/core';
+
+@Component(${decorator.join('\n')})
+export class ${toPascalCase(tagName)} {
+
+  render() {
+    return (
+      <Host>
+        <slot></slot>
+      </Host>
+    );
   }
- });
-}, configCase = e => (e = dashToPascalCase(e)).charAt(0).toLowerCase() + e.substr(1), ARG_OPTS = {
- boolean: [ "build", "cache", "check-version", "ci", "compare", "debug", "dev", "devtools", "docs", "e2e", "es5", "esm", "headless", "help", "log", "open", "prerender", "prerender-external", "prod", "profile", "service-worker", "screenshot", "serve", "skip-node-check", "spec", "stats", "update-screenshot", "verbose", "version", "watch" ],
- number: [ "max-workers", "port" ],
- string: [ "address", "config", "docs-json", "emulate", "log-level", "root", "screenshot-connector" ],
- alias: {
-  config: "c",
-  help: "h",
-  port: "p",
-  version: "v"
- }
-}, getNpmConfigEnvArgs = e => {
- let t = [];
- try {
-  const s = e.getEnvironmentVar("npm_config_argv");
-  s && (t = JSON.parse(s).original, "run" === t[0] && (t = t.slice(2)));
- } catch (e) {}
- return t;
-}, dependencies = [ {
- name: "@rindo/core",
- version: "0.0.0-dev.20221104122636",
- main: "compiler/rindo.js",
- resources: [ "internal/index.js", "internal/index.d.ts", "internal/package.json", "internal/rindo-core/index.js", "internal/rindo-core/index.d.ts", "internal/rindo-ext-modules.d.ts", "internal/rindo-private.d.ts", "internal/rindo-public-compiler.d.ts", "internal/rindo-public-docs.d.ts", "internal/rindo-public-runtime.d.ts", "internal/client/css-shim.js", "internal/client/dom.js", "internal/client/index.js", "internal/client/patch.js", "internal/client/shadow-css.js", "internal/client/package.json", "internal/hydrate/index.js", "internal/hydrate/runner.js", "internal/hydrate/shadow-css.js", "internal/hydrate/package.json", "mock-doc/index.js", "mock-doc/package.json", "package.json" ]
-}, {
- name: "typescript",
- version: "3.9.7",
- main: "lib/typescript.js",
- resources: [ "lib/lib.dom.d.ts", "lib/lib.es2015.d.ts", "lib/lib.es5.d.ts", "lib/lib.es2015.core.d.ts", "lib/lib.es2015.collection.d.ts", "lib/lib.es2015.generator.d.ts", "lib/lib.es2015.iterable.d.ts", "lib/lib.es2015.symbol.d.ts", "lib/lib.es2015.promise.d.ts", "lib/lib.es2015.proxy.d.ts", "lib/lib.es2015.reflect.d.ts", "lib/lib.es2015.symbol.wellknown.d.ts", "lib/lib.es2016.d.ts", "lib/lib.es2016.array.include.d.ts", "lib/lib.es2017.d.ts", "lib/lib.es2017.typedarrays.d.ts", "lib/lib.es2017.intl.d.ts", "lib/lib.es2017.object.d.ts", "lib/lib.es2017.sharedmemory.d.ts", "lib/lib.es2017.string.d.ts", "lib/lib.es2018.d.ts", "lib/lib.es2018.asyncgenerator.d.ts", "lib/lib.es2018.asynciterable.d.ts", "lib/lib.es2018.promise.d.ts", "lib/lib.es2018.regexp.d.ts", "lib/lib.es2018.intl.d.ts", "lib/lib.esnext.intl.d.ts", "lib/lib.es2020.bigint.d.ts", "package.json" ]
-}, {
- name: "rollup",
- version: "2.23.0",
- main: "dist/rollup.browser.es.js"
-}, {
- name: "terser",
- version: "4.8.0",
- main: "dist/bundle.min.js"
-} ], startupCompilerLog = (e, t) => {
- if (!0 === t.suppressLogs) return;
- const {logger: s} = t, n = "debug" === s.getLevel(), r = e.version.includes("-"), o = e.version.includes("-dev.");
- r && !o && s.warn(s.yellow("This is a prerelease build, undocumented changes might happen at any time. Technical support is not available for prereleases, but any assistance testing is appreciated.")), 
- t.devMode && !n && (t.buildEs5 && s.warn("Generating ES5 during development is a very task expensive, initial and incremental builds will be much slower. Drop the '--es5' flag and use a modern browser for development."), 
- t.enableCache || s.warn("Disabling cache during development will slow down incremental builds."));
-}, runPrerenderTask = async (e, t, s, n, r) => {
- const o = [];
- try {
-  const i = await e.createPrerenderer(t), a = await i.start({
-   hydrateAppFilePath: s,
-   componentGraph: n,
-   srcIndexHtmlPath: r
-  });
-  o.push(...a.diagnostics);
- } catch (e) {
-  ((e, t, s) => {
-   const n = {
-    level: "error",
-    type: "build",
-    header: "Build Error",
-    messageText: "build error",
-    relFilePath: null,
-    absFilePath: null,
-    lines: []
-   };
-   isString(void 0) ? n.messageText = void 0 : null != t && (null != t.stack ? n.messageText = t.stack.toString() : null != t.message ? n.messageText = t.message.toString() : n.messageText = t.toString()), 
-   null == e || shouldIgnoreError(n.messageText) || e.push(n);
-  })(o, e);
- }
- return o;
-}, startCheckVersion = async (e, t) => e.devMode && !e.flags.ci && !t.includes("-dev.") && isFunction(e.sys.checkVersion) ? e.sys.checkVersion(e.logger, t) : null, printCheckVersionResults = async e => {
- if (e) {
-  const t = await e;
-  isFunction(t) && t();
- }
-}, isOutputTargetDocs = e => e.type === DOCS || e.type === DOCS_README || e.type === DOCS_JSON || e.type === DOCS_CUSTOM || e.type === DOCS_VSCODE, DOCS = "docs", DOCS_CUSTOM = "docs-custom", DOCS_JSON = "docs-json", DOCS_README = "docs-readme", DOCS_VSCODE = "docs-vscode", chooseFilesToGenerate = async () => {
- const {prompt: e} = await import("../sys/node/prompts.js");
- return (await e({
-  name: "filesToGenerate",
-  type: "multiselect",
-  message: "Which additional files do you want to generate?",
-  choices: [ {
-   value: "css",
-   title: "Stylesheet (.css)",
-   selected: !0
-  }, {
-   value: "spec.tsx",
-   title: "Spec Test  (.spec.tsx)",
-   selected: !0
-  }, {
-   value: "e2e.ts",
-   title: "E2E Test (.e2e.ts)",
-   selected: !0
-  } ]
- })).filesToGenerate;
-}, isTest = e => "e2e.ts" === e || "spec.tsx" === e, getBoilerplateByExtension = (e, t, s) => {
- switch (t) {
- case "tsx":
-  return getComponentBoilerplate(e, s);
-
- case "css":
-  return getStyleUrlBoilerplate();
-
- case "spec.tsx":
-  return getSpecTestBoilerplate(e);
-
- case "e2e.ts":
-  return getE2eTestBoilerplate(e);
-
- default:
-  throw new Error(`Unkown extension "${t}".`);
- }
-}, getComponentBoilerplate = (e, t) => {
- const s = [ "{" ];
- return s.push(`  tag: '${e}',`), t && s.push(`  styleUrl: '${e}.css',`), s.push("  shadow: true,"), 
- s.push("}"), `import { Component, Host, h } from '@rindo/core';\n\n@Component(${s.join("\n")})\nexport class ${toPascalCase(e)} {\n\n  render() {\n    return (\n      <Host>\n        <slot></slot>\n      </Host>\n    );\n  }\n\n}\n`;
-}, getStyleUrlBoilerplate = () => ":host {\n  display: block;\n}\n", getSpecTestBoilerplate = e => `import { newSpecPage } from '@rindo/core/testing';\nimport { ${toPascalCase(e)} } from '../${e}';\n\ndescribe('${e}', () => {\n  it('renders', async () => {\n    const page = await newSpecPage({\n      components: [${toPascalCase(e)}],\n      html: \`<${e}></${e}>\`,\n    });\n    expect(page.root).toEqualHtml(\`\n      <${e}>\n        <mock:shadow-root>\n          <slot></slot>\n        </mock:shadow-root>\n      </${e}>\n    \`);\n  });\n});\n`, getE2eTestBoilerplate = e => `import { newE2EPage } from '@rindo/core/testing';\n\ndescribe('${e}', () => {\n  it('renders', async () => {\n    const page = await newE2EPage();\n    await page.setContent('<${e}></${e}>');\n\n    const element = await page.find('${e}');\n    expect(element).toHaveClass('hydrated');\n  });\n});\n`, toPascalCase = e => e.split("-").reduce((e, t) => e + t[0].toUpperCase() + t.substr(1), ""), taskHelp = (e, t) => {
- const s = t.dim("windows" === e.details.platform ? ">" : "$");
- console.log(`\n  ${t.bold("Build:")} ${t.dim("Build components for development or production.")}\n\n    ${s} ${t.green("rindo build [--dev] [--watch] [--prerender] [--debug]")}\n\n      ${t.cyan("--dev")} ${t.dim(".............")} Development build\n      ${t.cyan("--watch")} ${t.dim("...........")} Rebuild when files update\n      ${t.cyan("--serve")} ${t.dim("...........")} Start the dev-server\n      ${t.cyan("--prerender")} ${t.dim(".......")} Prerender the application\n      ${t.cyan("--docs")} ${t.dim("............")} Generate component readme.md docs\n      ${t.cyan("--config")} ${t.dim("..........")} Set rindo config file\n      ${t.cyan("--stats")} ${t.dim("...........")} Write rindo-stats.json file\n      ${t.cyan("--log")} ${t.dim(".............")} Write rindo-build.log file\n      ${t.cyan("--debug")} ${t.dim("...........")} Set the log level to debug\n\n\n  ${t.bold("Test:")} ${t.dim("Run unit and end-to-end tests.")}\n\n    ${s} ${t.green("rindo test [--spec] [--e2e]")}\n\n      ${t.cyan("--spec")} ${t.dim("............")} Run unit tests with Jest\n      ${t.cyan("--e2e")} ${t.dim(".............")} Run e2e tests with Puppeteer\n\n\n  ${t.bold("Generate:")} ${t.dim("Bootstrap components.")}\n\n    ${s} ${t.green("rindo generate")} or ${t.green("rindo g")}\n\n\n  ${t.bold("Examples:")}\n\n    ${s} ${t.green("rindo build --dev --watch --serve")}\n    ${s} ${t.green("rindo build --prerender")}\n    ${s} ${t.green("rindo test --spec --e2e")}\n    ${s} ${t.green("rindo generate")}\n    ${s} ${t.green("rindo g my-component")}\n\n`);
-}, run = async e => {
- const {args: t, logger: s, sys: n} = e;
- try {
-  const e = parseFlags(t, n), r = e.task;
-  if ((e.debug || e.verbose) && s.setLevel("debug"), e.ci && s.enableColors(!1), isFunction(n.applyGlobalPatch) && n.applyGlobalPatch(n.getCurrentDirectory()), 
-  "help" === r || e.help) return void taskHelp(n, s);
-  ((e, t) => {
-   "info" !== t && "serve" !== t && "version" !== t && e.info(e.cyan("@rindo/core"));
-  })(s, r);
-  const o = await (async e => {
-   const t = e.sys, s = t.getCurrentDirectory(), n = {
-    configPath: null,
-    rootDir: normalizePath(s),
-    diagnostics: []
-   };
-   let r = e.configPath;
-   r = isString(r) ? t.platformPath.isAbsolute(r) ? normalizePath(e.configPath) : normalizePath(t.platformPath.join(s, r)) : n.rootDir;
-   const o = await t.stat(r);
-   if (!o) {
-    const e = (e => {
-     const t = {
-      level: "error",
-      type: "build",
-      header: "Build Error",
-      messageText: "build error",
-      relFilePath: null,
-      absFilePath: null,
-      lines: []
-     };
-     return e && e.push(t), t;
-    })(n.diagnostics);
-    return e.absFilePath = r, e.header = "Invalid config path", e.messageText = `Config path "${r}" not found`, 
-    n;
-   }
-   if (o.isFile()) n.configPath = r, n.rootDir = t.platformPath.dirname(r); else if (o.isDirectory()) for (const e of [ "rindo.config.ts", "rindo.config.js" ]) {
-    const s = t.platformPath.join(r, e), o = await t.stat(s);
-    if (o && o.isFile()) {
-     n.configPath = s, n.rootDir = t.platformPath.dirname(s);
-     break;
-    }
-   }
-   return n;
-  })({
-   sys: n,
-   configPath: e.config
-  });
-  hasError(o.diagnostics) && (s.printDiagnostics(o.diagnostics), n.exit(1));
-  const i = await n.ensureDependencies({
-   rootDir: o.rootDir,
-   logger: s,
-   dependencies
+
+}
+`;
+};
+/**
+ * Get the boilerplate for style.
+ */
+const getStyleUrlBoilerplate = () => `:host {
+  display: block;
+}
+`;
+/**
+ * Get the boilerplate for a spec test.
+ */
+const getSpecTestBoilerplate = (tagName) => `import { newSpecPage } from '@rindo/core/testing';
+import { ${toPascalCase(tagName)} } from '../${tagName}';
+
+describe('${tagName}', () => {
+  it('renders', async () => {
+    const page = await newSpecPage({
+      components: [${toPascalCase(tagName)}],
+      html: \`<${tagName}></${tagName}>\`,
+    });
+    expect(page.root).toEqualHtml(\`
+      <${tagName}>
+        <mock:shadow-root>
+          <slot></slot>
+        </mock:shadow-root>
+      </${tagName}>
+    \`);
   });
-  hasError(i.diagnostics) && (s.printDiagnostics(i.diagnostics), n.exit(1));
-  const a = await (async e => (await e.dynamicImport(e.getCompilerExecutingPath()), 
-  globalThis.rindo))(n);
-  if ("version" === r || e.version) return void console.log(a.version);
-  if (((e, t, s) => {
-   if ("info" === t || "serve" === t || "version" === t) return;
-   let n;
-   n = s.version.includes("-dev.") ? e.yellow("[LOCAL DEV]") : e.cyan("v" + s.version), 
-   n += e.emoji(" " + s.vermoji), e.info(n);
-  })(s, r, a), ((e, t, s, n) => {
-   const r = e.details, o = `${e.name} ${e.version}`, i = `${r.platform}, ${r.cpuModel}`, a = `cpus: ${e.hardwareConcurrency}, freemem: ${Math.round(r.freemem() / 1e6)}MB, totalmem: ${Math.round(r.totalmem / 1e6)}MB`;
-   "debug" === t.getLevel() ? (t.debug(o), t.debug(i), t.debug(a), t.debug("compiler: " + e.getCompilerExecutingPath()), 
-   t.debug("build: " + n.buildId)) : s.ci && (t.info(o), t.info(i), t.info(a));
-  })(n, s, e, a), "info" === r) return void ((e, t, s) => {
-   const n = t.details, r = e.versions;
-   console.log(""), console.log(`${s.cyan("      System:")} ${t.name} ${t.version}`), 
-   console.log(`${s.cyan("     Plaform:")} ${n.platform} (${n.release})`), console.log(`${s.cyan("   CPU Model:")} ${n.cpuModel} (${t.hardwareConcurrency} cpu${1 !== t.hardwareConcurrency ? "s" : ""})`), 
-   console.log(`${s.cyan("    Compiler:")} ${t.getCompilerExecutingPath()}`), console.log(`${s.cyan("       Build:")} ${e.buildId}`), 
-   console.log(`${s.cyan("       Rindo:")} ${e.version}${s.emoji(" " + e.vermoji)}`), 
-   console.log(`${s.cyan("  TypeScript:")} ${r.typescript}`), console.log(`${s.cyan("      Rollup:")} ${r.rollup}`), 
-   console.log(`${s.cyan("      Terser:")} ${r.terser}`), console.log("");
-  })(a, n, s);
-  const l = await a.loadConfig({
-   config: {
-    flags: e
-   },
-   configPath: o.configPath,
-   logger: s,
-   sys: n,
-   typescriptPath: i.typescriptPath
+});
+`;
+/**
+ * Get the boilerplate for an E2E test.
+ */
+const getE2eTestBoilerplate = (name) => `import { newE2EPage } from '@rindo/core/testing';
+
+describe('${name}', () => {
+  it('renders', async () => {
+    const page = await newE2EPage();
+    await page.setContent('<${name}></${name}>');
+
+    const element = await page.find('${name}');
+    expect(element).toHaveClass('hydrated');
   });
-  l.diagnostics.length > 0 && (s.printDiagnostics(l.diagnostics), hasError(l.diagnostics) && n.exit(1)), 
-  isFunction(n.applyGlobalPatch) && n.applyGlobalPatch(l.config.rootDir), await n.ensureResources({
-   rootDir: l.config.rootDir,
-   logger: s,
-   dependencies
-  }), await runTask(a, l.config, r);
- } catch (e) {
-  shouldIgnoreError(e) || (s.error(`uncaught cli error: ${e}${"debug" === s.getLevel() ? e.stack : ""}`), 
-  n.exit(1));
- }
-}, runTask = async (e, t, s) => {
- switch (t.flags = t.flags || {}, t.outputTargets = t.outputTargets || [], s) {
- case "build":
-  await (async (e, t) => {
-   if (t.flags.watch) return void await (async (e, t) => {
-    let s = null, n = 0;
-    try {
-     startupCompilerLog(e, t);
-     const r = startCheckVersion(t, e.version), o = await e.createCompiler(t), i = await o.createWatcher();
-     if (t.flags.serve) {
-      const e = t.sys.getDevServerExecutingPath(), {start: n} = await t.sys.dynamicImport(e);
-      s = await n(t.devServer, t.logger, i);
-     }
-     t.sys.onProcessInterrupt(() => {
-      t.logger.debug("close watch"), o && o.destroy();
-     });
-     const a = i.on("buildFinish", async () => {
-      a(), printCheckVersionResults(r);
-     });
-     if (s) {
-      const e = i.on("buildFinish", () => {
-       e(), t.logger.info(t.logger.cyan(s.browserUrl) + "\n");
-      });
-     }
-     t.flags.prerender && i.on("buildFinish", async s => {
-      if (!s.hasError) {
-       const n = await runPrerenderTask(e, t, s.hydrateAppFilePath, s.componentGraph, null);
-       t.logger.printDiagnostics(n);
-      }
-     });
-     const l = await i.start();
-     l.exitCode > 0 && (n = l.exitCode);
-    } catch (e) {
-     n = 1, t.logger.error(e);
-    }
-    s && await s.close(), n > 0 && t.sys.exit(n);
-   })(e, t);
-   let s = 0;
-   try {
-    startupCompilerLog(e, t);
-    const n = startCheckVersion(t, e.version), r = await e.createCompiler(t), o = await r.build();
-    if (await r.destroy(), o.hasError) s = 1; else if (t.flags.prerender) {
-     const n = await runPrerenderTask(e, t, o.hydrateAppFilePath, o.componentGraph, null);
-     t.logger.printDiagnostics(n), n.some(e => "error" === e.level) && (s = 1);
-    }
-    await printCheckVersionResults(n);
-   } catch (e) {
-    s = 1, t.logger.error(e);
-   }
-   s > 0 && t.sys.exit(s);
-  })(e, t);
-  break;
-
- case "docs":
-  await (async (e, t) => {
-   t.devServer = null, t.outputTargets = t.outputTargets.filter(isOutputTargetDocs), 
-   t.devMode = !0, startupCompilerLog(e, t);
-   const s = await e.createCompiler(t);
-   await s.build(), await s.destroy();
-  })(e, t);
-  break;
-
- case "help":
-  taskHelp(t.sys, t.logger);
-  break;
-
- case "generate":
- case "g":
-  await (async (e, t) => {
-   IS_NODE_ENV || (t.logger.error('"generate" command is currently only implemented for a NodeJS environment'), 
-   t.sys.exit(1));
-   const s = e.path;
-   t.configPath || (t.logger.error("Please run this command in your root directory (i. e. the one containing rindo.config.ts)."), 
-   t.sys.exit(1));
-   const n = t.srcDir;
-   n || (t.logger.error("Rindo's srcDir was not specified."), t.sys.exit(1));
-   const {prompt: r} = await import("../sys/node/prompts.js"), o = t.flags.unknownArgs.find(e => !e.startsWith("-")) || (await r({
-    name: "tagName",
-    type: "text",
-    message: "Component tag name (dash-case):"
-   })).tagName, {dir: i, base: a} = s.parse(o), l = (e => {
-    if (e !== e.trim()) return "Tag can not contain white spaces";
-    if (e !== e.toLowerCase()) return "Tag can not contain upper case characters";
-    if ("string" != typeof e) return `Tag "${e}" must be a string type`;
-    if (0 === e.length) return "Received empty tag value";
-    if (e.indexOf(" ") > -1) return `"${e}" tag cannot contain a space`;
-    if (e.indexOf(",") > -1) return `"${e}" tag cannot be used for multiple tags`;
-    const t = e.replace(/\w|-/g, "");
-    return "" !== t ? `"${e}" tag contains invalid characters: ${t}` : -1 === e.indexOf("-") ? `"${e}" tag must contain a dash (-) to work as a valid web component` : e.indexOf("--") > -1 ? `"${e}" tag cannot contain multiple dashes (--) next to each other` : 0 === e.indexOf("-") ? `"${e}" tag cannot start with a dash (-)` : e.lastIndexOf("-") === e.length - 1 ? `"${e}" tag cannot end with a dash (-)` : void 0;
-   })(a);
-   l && (t.logger.error(l), t.sys.exit(1));
-   const c = [ "tsx", ...await chooseFilesToGenerate() ], d = c.some(isTest) ? "test" : "", g = s.join(n, "components", i, a);
-   await t.sys.mkdir(s.join(g, d), {
-    recursive: !0
-   });
-   const p = await Promise.all(c.map(s => (async (e, t, s, n, r, o) => {
-    isTest(r) && (s = e.path.join(s, "test"));
-    const i = e.path.join(s, `${n}.${r}`), a = getBoilerplateByExtension(n, r, o);
-    return await t.sys.writeFile(i, a), i;
-   })(e, t, g, a, s, c.includes("css")))).catch(e => t.logger.error(e));
-   if (!p) return t.sys.exit(1);
-   console.log(), console.log(`${t.logger.gray("$")} rindo generate ${o}`), console.log(), 
-   console.log(t.logger.bold("The following files have been generated:"));
-   const u = t.rootDir;
-   p.map(e => console.log("  - " + s.relative(u, e)));
-  })(e, t);
-  break;
-
- case "prerender":
-  await (async (e, t) => {
-   startupCompilerLog(e, t);
-   const s = t.flags.unknownArgs[0];
-   "string" != typeof s && (t.logger.error("Missing hydrate app script path"), t.sys.exit(1));
-   const n = t.srcIndexHtml, r = await runPrerenderTask(e, t, s, null, n);
-   t.logger.printDiagnostics(r), r.some(e => "error" === e.level) && t.sys.exit(1);
-  })(e, t);
-  break;
-
- case "serve":
-  await (async e => {
-   e.suppressLogs = !0, e.flags.serve = !0, e.devServer.openBrowser = e.flags.open, 
-   e.devServer.reloadStrategy = null, e.devServer.initialLoadUrl = "/", e.devServer.websocket = !1, 
-   e.maxConcurrentWorkers = 1, e.devServer.root = isString(e.flags.root) ? e.flags.root : e.sys.getCurrentDirectory();
-   const t = e.sys.getDevServerExecutingPath(), {start: s} = await e.sys.dynamicImport(t), n = await s(e.devServer, e.logger);
-   console.log(`${e.logger.cyan("     Root:")} ${n.root}`), console.log(`${e.logger.cyan("  Address:")} ${n.address}`), 
-   console.log(`${e.logger.cyan("     Port:")} ${n.port}`), console.log(`${e.logger.cyan("   Server:")} ${n.browserUrl}`), 
-   console.log(""), e.sys.onProcessInterrupt(() => {
-    n && (e.logger.debug("dev server close: " + n.browserUrl), n.close());
-   });
-  })(t);
-  break;
-
- case "test":
-  await (async e => {
-   IS_NODE_ENV || (e.logger.error('"test" command is currently only implemented for a NodeJS environment'), 
-   e.sys.exit(1));
-   try {
-    const t = {
-     e2e: !!e.flags.e2e,
-     screenshot: !!e.flags.screenshot,
-     spec: !!e.flags.spec,
-     updateScreenshot: !!e.flags.updateScreenshot
-    }, s = [ "@types/jest", "jest", "jest-cli" ];
-    if (t.e2e) {
-     const n = e.testing.browserExecutablePath ? "puppeteer-core" : "puppeteer";
-     s.push("@types/puppeteer", n), t.screenshot && e.logger.warn(e.logger.yellow("EXPERIMENTAL: screenshot visual diff testing is currently under heavy development and has not reached a stable status. However, any assistance testing would be appreciated."));
-    }
-    await e.sys.lazyRequire.ensure(e.logger, e.rootDir, s);
-    const {createTesting: n} = await import("../testing/index.js"), r = await n(e), o = await r.run(t);
-    await r.destroy(), o || e.sys.exit(1);
-   } catch (t) {
-    e.logger.error(t), e.sys.exit(1);
-   }
-  })(t);
-  break;
-
- case "version":
-  console.log(e.version);
-  break;
-
- default:
-  t.logger.error(t.logger.emoji("❌ ") + "Invalid rindo command, please see the options below:"), 
-  taskHelp(t.sys, t.logger), t.sys.exit(1);
- }
+});
+`;
+/**
+ * Convert a dash case string to pascal case.
+ */
+const toPascalCase = (str) => str.split('-').reduce((res, part) => res + part[0].toUpperCase() + part.substr(1), '');
+
+const taskHelp = (sys, logger) => {
+    const p = logger.dim(sys.details.platform === 'windows' ? '>' : '$');
+    console.log(`
+  ${logger.bold('Build:')} ${logger.dim('Build components for development or production.')}
+
+    ${p} ${logger.green('rindo build [--dev] [--watch] [--prerender] [--debug]')}
+
+      ${logger.cyan('--dev')} ${logger.dim('.............')} Development build
+      ${logger.cyan('--watch')} ${logger.dim('...........')} Rebuild when files update
+      ${logger.cyan('--serve')} ${logger.dim('...........')} Start the dev-server
+      ${logger.cyan('--prerender')} ${logger.dim('.......')} Prerender the application
+      ${logger.cyan('--docs')} ${logger.dim('............')} Generate component readme.md docs
+      ${logger.cyan('--config')} ${logger.dim('..........')} Set rindo config file
+      ${logger.cyan('--stats')} ${logger.dim('...........')} Write rindo-stats.json file
+      ${logger.cyan('--log')} ${logger.dim('.............')} Write rindo-build.log file
+      ${logger.cyan('--debug')} ${logger.dim('...........')} Set the log level to debug
+
+
+  ${logger.bold('Test:')} ${logger.dim('Run unit and end-to-end tests.')}
+
+    ${p} ${logger.green('rindo test [--spec] [--e2e]')}
+
+      ${logger.cyan('--spec')} ${logger.dim('............')} Run unit tests with Jest
+      ${logger.cyan('--e2e')} ${logger.dim('.............')} Run e2e tests with Puppeteer
+
+
+  ${logger.bold('Generate:')} ${logger.dim('Bootstrap components.')}
+
+    ${p} ${logger.green('rindo generate')} or ${logger.green('rindo g')}
+
+
+  ${logger.bold('Examples:')}
+
+    ${p} ${logger.green('rindo build --dev --watch --serve')}
+    ${p} ${logger.green('rindo build --prerender')}
+    ${p} ${logger.green('rindo test --spec --e2e')}
+    ${p} ${logger.green('rindo generate')}
+    ${p} ${logger.green('rindo g my-component')}
+
+`);
+};
+
+const taskInfo = (coreCompiler, sys, logger) => {
+    const details = sys.details;
+    const versions = coreCompiler.versions;
+    console.log(``);
+    console.log(`${logger.cyan('      System:')} ${sys.name} ${sys.version}`);
+    console.log(`${logger.cyan('     Plaform:')} ${details.platform} (${details.release})`);
+    console.log(`${logger.cyan('   CPU Model:')} ${details.cpuModel} (${sys.hardwareConcurrency} cpu${sys.hardwareConcurrency !== 1 ? 's' : ''})`);
+    console.log(`${logger.cyan('    Compiler:')} ${sys.getCompilerExecutingPath()}`);
+    console.log(`${logger.cyan('       Build:')} ${coreCompiler.buildId}`);
+    console.log(`${logger.cyan('       Rindo:')} ${coreCompiler.version}${logger.emoji(' ' + coreCompiler.vermoji)}`);
+    console.log(`${logger.cyan('  TypeScript:')} ${versions.typescript}`);
+    console.log(`${logger.cyan('      Rollup:')} ${versions.rollup}`);
+    console.log(`${logger.cyan('      Parse5:')} ${versions.parse5}`);
+    console.log(`${logger.cyan('      Sizzle:')} ${versions.sizzle}`);
+    console.log(`${logger.cyan('      Terser:')} ${versions.terser}`);
+    console.log(``);
+};
+
+const taskServe = async (config) => {
+    config.suppressLogs = true;
+    config.flags.serve = true;
+    config.devServer.openBrowser = config.flags.open;
+    config.devServer.reloadStrategy = null;
+    config.devServer.initialLoadUrl = '/';
+    config.devServer.websocket = false;
+    config.maxConcurrentWorkers = 1;
+    config.devServer.root = isString(config.flags.root) ? config.flags.root : config.sys.getCurrentDirectory();
+    const devServerPath = config.sys.getDevServerExecutingPath();
+    const { start } = await config.sys.dynamicImport(devServerPath);
+    const devServer = await start(config.devServer, config.logger);
+    console.log(`${config.logger.cyan('     Root:')} ${devServer.root}`);
+    console.log(`${config.logger.cyan('  Address:')} ${devServer.address}`);
+    console.log(`${config.logger.cyan('     Port:')} ${devServer.port}`);
+    console.log(`${config.logger.cyan('   Server:')} ${devServer.browserUrl}`);
+    console.log(``);
+    config.sys.onProcessInterrupt(() => {
+        if (devServer) {
+            config.logger.debug(`dev server close: ${devServer.browserUrl}`);
+            devServer.close();
+        }
+    });
+};
+
+const taskTest = async (config) => {
+    if (!IS_NODE_ENV) {
+        config.logger.error(`"test" command is currently only implemented for a NodeJS environment`);
+        return config.sys.exit(1);
+    }
+    try {
+        config.buildDocs = false;
+        const testingRunOpts = {
+            e2e: !!config.flags.e2e,
+            screenshot: !!config.flags.screenshot,
+            spec: !!config.flags.spec,
+            updateScreenshot: !!config.flags.updateScreenshot,
+        };
+        // always ensure we have jest modules installed
+        const ensureModuleIds = ['@types/jest', 'jest', 'jest-cli'];
+        if (testingRunOpts.e2e) {
+            // if it's an e2e test, also make sure we're got
+            // puppeteer modules installed and if browserExecutablePath is provided don't download Chromium use only puppeteer-core instead
+            const puppeteer = config.testing.browserExecutablePath ? 'puppeteer-core' : 'puppeteer';
+            ensureModuleIds.push('@types/puppeteer', puppeteer);
+            if (testingRunOpts.screenshot) {
+                // ensure we've got pixelmatch for screenshots
+                config.logger.warn(config.logger.yellow(`EXPERIMENTAL: screenshot visual diff testing is currently under heavy development and has not reached a stable status. However, any assistance testing would be appreciated.`));
+            }
+        }
+        // ensure we've got the required modules installed
+        const diagnostics = await config.sys.lazyRequire.ensure(config.rootDir, ensureModuleIds);
+        if (diagnostics.length > 0) {
+            config.logger.printDiagnostics(diagnostics);
+            return config.sys.exit(1);
+        }
+        // let's test!
+        const { createTesting } = await import('../testing/index.js');
+        const testing = await createTesting(config);
+        const passed = await testing.run(testingRunOpts);
+        await testing.destroy();
+        if (!passed) {
+            return config.sys.exit(1);
+        }
+    }
+    catch (e) {
+        config.logger.error(e);
+        return config.sys.exit(1);
+    }
+};
+
+const run = async (init) => {
+    const { args, logger, sys } = init;
+    try {
+        const flags = parseFlags(args, sys);
+        const task = flags.task;
+        if (flags.debug || flags.verbose) {
+            logger.setLevel('debug');
+        }
+        if (flags.ci) {
+            logger.enableColors(false);
+        }
+        if (isFunction(sys.applyGlobalPatch)) {
+            sys.applyGlobalPatch(sys.getCurrentDirectory());
+        }
+        if (task === 'help' || flags.help) {
+            taskHelp(sys, logger);
+            return;
+        }
+        startupLog(logger, task);
+        const findConfigResults = await findConfig({ sys, configPath: flags.config });
+        if (hasError(findConfigResults.diagnostics)) {
+            logger.printDiagnostics(findConfigResults.diagnostics);
+            return sys.exit(1);
+        }
+        const ensureDepsResults = await sys.ensureDependencies({
+            rootDir: findConfigResults.rootDir,
+            logger,
+            dependencies: dependencies,
+        });
+        if (hasError(ensureDepsResults.diagnostics)) {
+            logger.printDiagnostics(ensureDepsResults.diagnostics);
+            return sys.exit(1);
+        }
+        const coreCompiler = await loadCoreCompiler(sys);
+        if (task === 'version' || flags.version) {
+            console.log(coreCompiler.version);
+            return;
+        }
+        startupLogVersion(logger, task, coreCompiler);
+        loadedCompilerLog(sys, logger, flags, coreCompiler);
+        if (task === 'info') {
+            taskInfo(coreCompiler, sys, logger);
+            return;
+        }
+        const validated = await coreCompiler.loadConfig({
+            config: {
+                flags,
+            },
+            configPath: findConfigResults.configPath,
+            logger,
+            sys,
+        });
+        if (validated.diagnostics.length > 0) {
+            logger.printDiagnostics(validated.diagnostics);
+            if (hasError(validated.diagnostics)) {
+                return sys.exit(1);
+            }
+        }
+        if (isFunction(sys.applyGlobalPatch)) {
+            sys.applyGlobalPatch(validated.config.rootDir);
+        }
+        await sys.ensureResources({ rootDir: validated.config.rootDir, logger, dependencies: dependencies });
+        await runTask(coreCompiler, validated.config, task);
+    }
+    catch (e) {
+        if (!shouldIgnoreError(e)) {
+            logger.error(`uncaught cli error: ${e}${logger.getLevel() === 'debug' ? e.stack : ''}`);
+            return sys.exit(1);
+        }
+    }
+};
+const runTask = async (coreCompiler, config, task) => {
+    config.flags = config.flags || {};
+    config.outputTargets = config.outputTargets || [];
+    switch (task) {
+        case 'build':
+            await taskBuild(coreCompiler, config);
+            break;
+        case 'docs':
+            await taskDocs(coreCompiler, config);
+            break;
+        case 'help':
+            taskHelp(config.sys, config.logger);
+            break;
+        case 'generate':
+        case 'g':
+            await taskGenerate(coreCompiler, config);
+            break;
+        case 'prerender':
+            await taskPrerender(coreCompiler, config);
+            break;
+        case 'serve':
+            await taskServe(config);
+            break;
+        case 'test':
+            await taskTest(config);
+            break;
+        case 'version':
+            console.log(coreCompiler.version);
+            break;
+        default:
+            config.logger.error(`${config.logger.emoji('❌ ')}Invalid rindo command, please see the options below:`);
+            taskHelp(config.sys, config.logger);
+            return config.sys.exit(1);
+    }
 };
 
-export { parseFlags, run, runTask };
+export { parseFlags, run, runTask };