gonia 0.1.0 → 0.1.1

package/dist/client/hydrate.d.ts

@@ -26,7 +26,7 @@ export declare function setElementContext(el: Element, ctx: Context): void;
  * this directive and processes them immediately.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export declare function registerDirective(registry: DirectiveRegistry, name: string, fn: Directive): void;

package/dist/client/hydrate.js

@@ -252,7 +252,7 @@ function processNode(node, selector, registry) {
  * this directive and processes them immediately.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export function registerDirective(registry, name, fn) {

package/dist/directives/slot.js

@@ -56,14 +56,12 @@ export const slot = function slot($expr, $element, $eval) {
             return;
         }
         const content = getSavedContent(templateEl);
+        if (!content) {
+            return;
+        }
         const slotContent = content.slots.get(name);
         if (slotContent) {
             $element.innerHTML = slotContent;
-            // MutationObserver will process the new content
-        }
-        else {
-            // No content for this slot - could show fallback
-            // For now, leave any default content in the slot
         }
     };
     // If expression is provided, make it reactive
@@ -92,6 +90,9 @@ export function processNativeSlot(el) {
         return;
     }
     const content = getSavedContent(templateEl);
+    if (!content) {
+        return;
+    }
     const slotContent = content.slots.get(name);
     if (slotContent) {
         el.outerHTML = slotContent;

package/dist/directives/template.d.ts

@@ -52,4 +52,4 @@ export declare const template: Directive<['$expr', '$element', '$templates']>;
  *
  * @internal
  */
-export declare function getElementScope(el: Element): EffectScope | undefined;
+export declare function getEffectScope(el: Element): EffectScope | undefined;

package/dist/directives/template.js

@@ -142,6 +142,6 @@ directive('g-template', template);
  *
  * @internal
  */
-export function getElementScope(el) {
+export function getEffectScope(el) {
     return elementScopes.get(el);
 }

package/dist/expression.d.ts

@@ -41,7 +41,7 @@ export interface Segment {
  *
  * @remarks
  * Splits a template string with `{{ expr }}` markers into segments
- * of static text and expressions. Used by directives like c-href
+ * of static text and expressions. Useful for directives
  * that support inline interpolation.
  *
  * @param template - The template string with interpolation markers

package/dist/expression.js

@@ -52,7 +52,7 @@ export function findRoots(expr) {
  *
  * @remarks
  * Splits a template string with `{{ expr }}` markers into segments
- * of static text and expressions. Used by directives like c-href
+ * of static text and expressions. Useful for directives
  * that support inline interpolation.
  *
  * @param template - The template string with interpolation markers

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Cubist.js - A modern framework inspired by AngularJS 1.
+ * Gonia - A lightweight, SSR-first reactive UI library.
  *
  * @remarks
  * SSR-first design with HTML attributes as directives.
@@ -16,4 +16,5 @@ export { createTemplateRegistry, createMemoryRegistry, createServerRegistry } fr
 export type { TemplateRegistry } from './templates.js';
 export { findRoots, parseInterpolation } from './expression.js';
 export { getInjectables } from './inject.js';
+export { getRootScope, clearRootScope } from './scope.js';
 export * as directives from './directives/index.js';

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * Cubist.js - A modern framework inspired by AngularJS 1.
+ * Gonia - A lightweight, SSR-first reactive UI library.
  *
  * @remarks
  * SSR-first design with HTML attributes as directives.
@@ -13,4 +13,5 @@ export { reactive, effect, createScope, createEffectScope } from './reactivity.j
 export { createTemplateRegistry, createMemoryRegistry, createServerRegistry } from './templates.js';
 export { findRoots, parseInterpolation } from './expression.js';
 export { getInjectables } from './inject.js';
+export { getRootScope, clearRootScope } from './scope.js';
 export * as directives from './directives/index.js';

package/dist/scope.d.ts

@@ -4,6 +4,24 @@
  * @packageDocumentation
  */
 import { Directive, DirectiveOptions } from './types.js';
+/**
+ * Get or create the root scope.
+ *
+ * @remarks
+ * The root scope is used as a fallback for directives that aren't
+ * inside an element with `scope: true`. This allows top-level
+ * directives like `g-model` to work without requiring a parent scope.
+ *
+ * @returns The root reactive scope
+ */
+export declare function getRootScope(): Record<string, unknown>;
+/**
+ * Clear the root scope.
+ *
+ * @remarks
+ * Primarily useful for testing.
+ */
+export declare function clearRootScope(): void;
 /**
  * Create a new scope for an element.
  *
@@ -24,9 +42,10 @@ export declare function getElementScope(el: Element): Record<string, unknown> |
  *
  * @param el - The element to start from
  * @param includeSelf - Whether to check the element itself (default: false)
- * @returns The nearest scope, or undefined if none found
+ * @param useRootFallback - Whether to return root scope if no parent found (default: true)
+ * @returns The nearest scope, or root scope if none found and fallback enabled
  */
-export declare function findParentScope(el: Element, includeSelf?: boolean): Record<string, unknown> | undefined;
+export declare function findParentScope(el: Element, includeSelf?: boolean, useRootFallback?: boolean): Record<string, unknown> | undefined;
 /**
  * Remove scope for an element (cleanup).
  *

package/dist/scope.js

@@ -9,6 +9,33 @@ import { Mode } from './types.js';
 import { getInjectables } from './inject.js';
 /** WeakMap to store element scopes */
 const elementScopes = new WeakMap();
+/** Root scope for top-level directives without explicit parent scope */
+let rootScope = null;
+/**
+ * Get or create the root scope.
+ *
+ * @remarks
+ * The root scope is used as a fallback for directives that aren't
+ * inside an element with `scope: true`. This allows top-level
+ * directives like `g-model` to work without requiring a parent scope.
+ *
+ * @returns The root reactive scope
+ */
+export function getRootScope() {
+    if (!rootScope) {
+        rootScope = reactive({});
+    }
+    return rootScope;
+}
+/**
+ * Clear the root scope.
+ *
+ * @remarks
+ * Primarily useful for testing.
+ */
+export function clearRootScope() {
+    rootScope = null;
+}
 /**
  * Create a new scope for an element.
  *
@@ -42,9 +69,10 @@ export function getElementScope(el) {
  *
  * @param el - The element to start from
  * @param includeSelf - Whether to check the element itself (default: false)
- * @returns The nearest scope, or undefined if none found
+ * @param useRootFallback - Whether to return root scope if no parent found (default: true)
+ * @returns The nearest scope, or root scope if none found and fallback enabled
  */
-export function findParentScope(el, includeSelf = false) {
+export function findParentScope(el, includeSelf = false, useRootFallback = true) {
     let current = includeSelf ? el : el.parentElement;
     while (current) {
         const scope = elementScopes.get(current);
@@ -53,7 +81,8 @@ export function findParentScope(el, includeSelf = false) {
         }
         current = current.parentElement;
     }
-    return undefined;
+    // Fall back to root scope for top-level directives
+    return useRootFallback ? getRootScope() : undefined;
 }
 /**
  * Remove scope for an element (cleanup).

package/dist/server/render.d.ts

@@ -19,7 +19,7 @@ export type ServiceRegistry = Map<string, unknown>;
  * Invalidates the cached selector so it will be rebuilt on next render.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export declare function registerDirective(registry: DirectiveRegistry, name: string, fn: Directive): void;

package/dist/server/render.js

@@ -36,7 +36,7 @@ function getSelector(registry) {
  * Invalidates the cached selector so it will be rebuilt on next render.
  *
  * @param registry - The directive registry
- * @param name - Directive name (without c- prefix)
+ * @param name - Directive name (without g- prefix)
  * @param fn - The directive function
  */
 export function registerDirective(registry, name, fn) {

package/dist/vite/plugin.d.ts

@@ -3,6 +3,7 @@
  *
  * @remarks
  * - Auto-detects directive usage in templates and injects imports
+ * - Scans custom directive sources to build import map
  * - Transforms directive functions to add $inject arrays at build time
  * - Configures Vite for SSR with gonia.js
  *
@@ -20,21 +21,40 @@ export interface GoniaPluginOptions {
     autoDirectives?: boolean;
     /**
      * Additional directives to include (for runtime/dynamic cases).
-     * Use directive names without the 'g-' prefix.
-     * @example ['text', 'for', 'if']
+     * Use full directive names (e.g., 'g-text', 'my-component').
+     * @example ['g-text', 'g-for', 'app-header']
      */
     includeDirectives?: string[];
     /**
      * Directives to exclude from auto-detection.
-     * Use directive names without the 'g-' prefix.
+     * Use full directive names.
      */
     excludeDirectives?: string[];
+    /**
+     * Glob patterns for files containing custom directive definitions.
+     * The plugin scans these files at build start to discover directive() calls.
+     * @example ['src/directives/**\/*.ts']
+     */
+    directiveSources?: string[];
+    /**
+     * Prefixes for attribute directives.
+     * @defaultValue ['g-']
+     * @example ['g-', 'v-', 'x-']
+     */
+    directiveAttributePrefixes?: string[];
+    /**
+     * Prefixes for element/component directives.
+     * Defaults to directiveAttributePrefixes if not specified.
+     * @example ['app-', 'my-', 'ui-']
+     */
+    directiveElementPrefixes?: string[];
 }
 /**
  * Gonia Vite plugin.
  *
  * @remarks
  * - Auto-detects directive usage and injects imports
+ * - Scans custom directive sources to discover user directives
  * - Adds $inject arrays to directive functions for minification safety
  * - Configures Vite for SSR with gonia.js
  *
@@ -51,12 +71,12 @@ export interface GoniaPluginOptions {
  *
  * @example
  * ```ts
- * // With options
+ * // With custom directives
  * export default defineConfig({
  *   plugins: [gonia({
- *     autoDirectives: true,
- *     includeDirectives: ['text', 'for'],  // For dynamic/runtime HTML
- *     excludeDirectives: ['model'],        // Never include these
+ *     directiveSources: ['src/directives/**\/*.ts'],
+ *     directiveAttributePrefixes: ['g-'],
+ *     directiveElementPrefixes: ['app-', 'ui-'],
  *   })]
  * });
  * ```

package/dist/vite/plugin.js

@@ -3,90 +3,170 @@
  *
  * @remarks
  * - Auto-detects directive usage in templates and injects imports
+ * - Scans custom directive sources to build import map
  * - Transforms directive functions to add $inject arrays at build time
  * - Configures Vite for SSR with gonia.js
  *
  * @packageDocumentation
  */
+import { readFileSync } from 'fs';
+import { glob } from 'tinyglobby';
+import { relative } from 'path';
 /**
- * Map of directive names to their export names from gonia.
+ * Map of built-in directive names to their export names from gonia.
  */
-const DIRECTIVE_MAP = {
-    text: 'text',
-    html: 'html',
-    show: 'show',
-    template: 'template',
-    slot: 'slot',
-    class: 'cclass',
-    model: 'model',
-    on: 'on',
-    for: 'cfor',
-    if: 'cif',
+const BUILTIN_DIRECTIVES = {
+    'g-text': { exportName: 'text', module: 'gonia/directives' },
+    'g-html': { exportName: 'html', module: 'gonia/directives' },
+    'g-show': { exportName: 'show', module: 'gonia/directives' },
+    'g-template': { exportName: 'template', module: 'gonia/directives' },
+    'g-slot': { exportName: 'slot', module: 'gonia/directives' },
+    'g-class': { exportName: 'cclass', module: 'gonia/directives' },
+    'g-model': { exportName: 'model', module: 'gonia/directives' },
+    'g-on': { exportName: 'on', module: 'gonia/directives' },
+    'g-for': { exportName: 'cfor', module: 'gonia/directives' },
+    'g-if': { exportName: 'cif', module: 'gonia/directives' },
 };
+/**
+ * Scan a file for directive() calls and extract directive names.
+ */
+function scanFileForDirectives(filePath) {
+    const directives = new Map();
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        // Match directive('name', ...) or directive("name", ...)
+        const pattern = /directive\s*\(\s*(['"`])([^'"`]+)\1/g;
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const name = match[2];
+            directives.set(name, {
+                name,
+                exportName: null,
+                module: filePath,
+                isBuiltin: false,
+            });
+        }
+    }
+    catch {
+        // File read error - skip silently
+    }
+    return directives;
+}
+/**
+ * Build regex pattern for matching directive attributes.
+ */
+function buildAttributePattern(prefixes) {
+    const escaped = prefixes.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    return new RegExp(`(?:${escaped.join('|')})([a-zA-Z][a-zA-Z0-9-]*)`, 'g');
+}
+/**
+ * Build regex pattern for matching directive elements (custom elements).
+ */
+function buildElementPattern(prefixes) {
+    const escaped = prefixes.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    return new RegExp(`<((?:${escaped.join('|')})[a-zA-Z][a-zA-Z0-9-]*)`, 'g');
+}
 /**
  * Detect directive names used in source code.
  */
-function detectDirectives(code, id, isDev) {
+function detectDirectives(code, id, isDev, attributePrefixes, elementPrefixes, customDirectives) {
     const found = new Set();
-    // Pattern 1: g-name as attribute in template literals or strings
-    // Matches: g-text, g-for, g-if, etc.
-    const attrPattern = /g-([a-z]+)/g;
+    // Pattern for attribute directives (e.g., g-text, v-if)
+    const attrPattern = buildAttributePattern(attributePrefixes);
     let match;
     while ((match = attrPattern.exec(code)) !== null) {
-        const name = match[1];
-        if (DIRECTIVE_MAP[name]) {
-            found.add(name);
-        }
+        // Reconstruct full attribute name
+        const fullMatch = match[0];
+        found.add(fullMatch);
     }
-    // Pattern 2: Dynamic directive names we can resolve
-    // Matches: `g-${expr}` where expr is a string literal or simple variable
-    const dynamicPattern = /`g-\$\{([^}]+)\}`/g;
-    while ((match = dynamicPattern.exec(code)) !== null) {
-        const expr = match[1].trim();
-        // Try to resolve simple string literals
-        if (/^['"]([a-z]+)['"]$/.test(expr)) {
-            const name = expr.slice(1, -1);
-            if (DIRECTIVE_MAP[name]) {
-                found.add(name);
-            }
-        }
-        else if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(expr)) {
-            // It's a variable - try to find its value
-            const varPattern = new RegExp(`(?:const|let|var)\\s+${expr}\\s*=\\s*['"]([a-z]+)['"]`);
-            const varMatch = code.match(varPattern);
-            if (varMatch && DIRECTIVE_MAP[varMatch[1]]) {
-                found.add(varMatch[1]);
+    // Pattern for element directives (e.g., <app-header>, <my-component>)
+    const elemPattern = buildElementPattern(elementPrefixes);
+    while ((match = elemPattern.exec(code)) !== null) {
+        const elementName = match[1];
+        found.add(elementName);
+    }
+    // Handle dynamic directive names we can resolve
+    for (const prefix of attributePrefixes) {
+        const escaped = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const dynamicPattern = new RegExp(`\`${escaped}\\$\\{([^}]+)\\}\``, 'g');
+        while ((match = dynamicPattern.exec(code)) !== null) {
+            const expr = match[1].trim();
+            // Try to resolve simple string literals
+            const literalMatch = expr.match(/^['"]([a-zA-Z][a-zA-Z0-9-]*)['"]$/);
+            if (literalMatch) {
+                found.add(prefix + literalMatch[1]);
+                continue;
             }
-            else if (isDev) {
-                console.warn(`[gonia] Could not resolve directive name in \`g-\${${expr}}\` at ${id}\n` +
-                    `        Add to vite config: includeDirectives: ['expected-directive']`);
+            // Try to resolve variable
+            if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(expr)) {
+                const varPattern = new RegExp(`(?:const|let|var)\\s+${expr}\\s*=\\s*['"]([a-zA-Z][a-zA-Z0-9-]*)['"]`);
+                const varMatch = code.match(varPattern);
+                if (varMatch) {
+                    found.add(prefix + varMatch[1]);
+                }
+                else if (isDev) {
+                    console.warn(`[gonia] Could not resolve directive name in \`${prefix}\${${expr}}\` at ${id}\n` +
+                        `        Add to includeDirectives: ['${prefix}expected-name']`);
+                }
             }
         }
     }
     return found;
 }
 /**
- * Generate import statement for detected directives.
+ * Generate import statements for detected directives.
  */
-function generateDirectiveImports(directives) {
+function generateImports(directives, customDirectives, currentFile, rootDir) {
     if (directives.size === 0)
         return '';
-    const imports = [];
+    // Group by module
+    const moduleImports = new Map();
     for (const name of directives) {
-        const exportName = DIRECTIVE_MAP[name];
-        if (exportName) {
-            imports.push(exportName);
+        // Check built-in first
+        const builtin = BUILTIN_DIRECTIVES[name];
+        if (builtin) {
+            const imports = moduleImports.get(builtin.module) ?? [];
+            if (!imports.includes(builtin.exportName)) {
+                imports.push(builtin.exportName);
+            }
+            moduleImports.set(builtin.module, imports);
+            continue;
+        }
+        // Check custom directives
+        const custom = customDirectives.get(name);
+        if (custom) {
+            // For custom directives, we import the whole module (side effect)
+            // since the directive() call registers it
+            let modulePath = custom.module;
+            // Make path relative to current file
+            if (modulePath.startsWith('/') || modulePath.match(/^[a-zA-Z]:\\/)) {
+                const relPath = relative(currentFile.replace(/[/\\][^/\\]+$/, ''), modulePath);
+                modulePath = relPath.startsWith('.') ? relPath : './' + relPath;
+                // Normalize to forward slashes and remove .ts extension for import
+                modulePath = modulePath.replace(/\\/g, '/').replace(/\.tsx?$/, '.js');
+            }
+            // Side-effect import
+            const imports = moduleImports.get(modulePath) ?? [];
+            moduleImports.set(modulePath, imports);
         }
     }
-    if (imports.length === 0)
-        return '';
-    // Import from gonia/directives which auto-registers
-    return `import { ${imports.join(', ')} } from 'gonia/directives';\n`;
+    // Generate import statements
+    const statements = [];
+    for (const [module, imports] of moduleImports) {
+        if (imports.length > 0) {
+            statements.push(`import { ${imports.join(', ')} } from '${module}';`);
+        }
+        else {
+            // Side-effect import for custom directives
+            statements.push(`import '${module}';`);
+        }
+    }
+    return statements.length > 0 ? statements.join('\n') + '\n' : '';
 }
 /**
  * Transform source code to add $inject arrays to directive functions.
  */
-function transformInject(code, id) {
+function transformInject(code) {
     if (!code.includes('directive(')) {
         return { code, modified: false };
     }
@@ -131,6 +211,7 @@ function transformInject(code, id) {
  *
  * @remarks
  * - Auto-detects directive usage and injects imports
+ * - Scans custom directive sources to discover user directives
  * - Adds $inject arrays to directive functions for minification safety
  * - Configures Vite for SSR with gonia.js
  *
@@ -147,26 +228,48 @@ function transformInject(code, id) {
  *
  * @example
  * ```ts
- * // With options
+ * // With custom directives
  * export default defineConfig({
  *   plugins: [gonia({
- *     autoDirectives: true,
- *     includeDirectives: ['text', 'for'],  // For dynamic/runtime HTML
- *     excludeDirectives: ['model'],        // Never include these
+ *     directiveSources: ['src/directives/**\/*.ts'],
+ *     directiveAttributePrefixes: ['g-'],
+ *     directiveElementPrefixes: ['app-', 'ui-'],
  *   })]
  * });
  * ```
  */
 export function gonia(options = {}) {
-    const { autoDirectives = true, includeDirectives = [], excludeDirectives = [], } = options;
+    const { autoDirectives = true, includeDirectives = [], excludeDirectives = [], directiveSources = [], directiveAttributePrefixes = ['g-'], directiveElementPrefixes = options.directiveElementPrefixes ?? options.directiveAttributePrefixes ?? ['g-'], } = options;
     let isDev = false;
-    // Track which directives have been injected per chunk
+    let rootDir = process.cwd();
+    // Map of custom directive name -> DirectiveInfo
+    const customDirectives = new Map();
+    // Track which modules have been processed
     const injectedModules = new Set();
     return {
         name: 'gonia',
         enforce: 'pre',
         configResolved(config) {
             isDev = config.command === 'serve';
+            rootDir = config.root;
+        },
+        async buildStart() {
+            // Scan directive sources to discover custom directives
+            if (directiveSources.length > 0) {
+                const files = await glob(directiveSources, {
+                    cwd: rootDir,
+                    absolute: true,
+                });
+                for (const file of files) {
+                    const directives = scanFileForDirectives(file);
+                    for (const [name, info] of directives) {
+                        customDirectives.set(name, info);
+                    }
+                }
+                if (isDev && customDirectives.size > 0) {
+                    console.log(`[gonia] Discovered ${customDirectives.size} custom directive(s)`);
+                }
+            }
         },
         transform(code, id) {
             // Skip node_modules (except for $inject transform in gonia itself)
@@ -182,11 +285,11 @@ export function gonia(options = {}) {
                 const detected = new Set();
                 // Auto-detect directives if enabled
                 if (autoDirectives) {
-                    for (const name of detectDirectives(code, id, isDev)) {
+                    for (const name of detectDirectives(code, id, isDev, directiveAttributePrefixes, directiveElementPrefixes, customDirectives)) {
                         detected.add(name);
                     }
                 }
-                // Add explicitly included directives (always, regardless of autoDirectives)
+                // Add explicitly included directives
                 for (const name of includeDirectives) {
                     detected.add(name);
                 }
@@ -197,18 +300,19 @@ export function gonia(options = {}) {
                 // Generate imports if we found directives and haven't already
                 if (detected.size > 0 && !injectedModules.has(id)) {
                     // Check if this file already imports from gonia/directives
-                    if (!code.includes("from 'gonia/directives'") && !code.includes('from "gonia/directives"')) {
-                        const importStatement = generateDirectiveImports(detected);
-                        if (importStatement) {
-                            result = importStatement + result;
-                            modified = true;
-                            injectedModules.add(id);
-                        }
+                    const hasGoniaImport = code.includes("from 'gonia/directives'") ||
+                        code.includes('from "gonia/directives"');
+                    // For custom directives, check if already imported
+                    const importStatement = generateImports(detected, customDirectives, id, rootDir);
+                    if (importStatement && !hasGoniaImport) {
+                        result = importStatement + result;
+                        modified = true;
+                        injectedModules.add(id);
                     }
                 }
             }
             // Transform $inject arrays
-            const injectResult = transformInject(result, id);
+            const injectResult = transformInject(result);
             if (injectResult.modified) {
                 result = injectResult.code;
                 modified = true;
@@ -216,7 +320,7 @@ export function gonia(options = {}) {
             if (modified) {
                 return {
                     code: result,
-                    map: null // TODO: proper source map support
+                    map: null
                 };
             }
             return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gonia",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A lightweight, SSR-first reactive UI library with declarative directives",
   "type": "module",
   "license": "MIT",
@@ -42,7 +42,8 @@
     }
   },
   "dependencies": {
-    "linkedom": "^0.18.0"
+    "linkedom": "^0.18.0",
+    "tinyglobby": "^0.2.15"
   },
   "peerDependencies": {
     "vite": ">=5.0.0"
@@ -53,10 +54,11 @@
     }
   },
   "devDependencies": {
+    "@types/node": "^25.0.10",
     "@vitest/coverage-v8": "^4.0.17",
     "jsdom": "^27.4.0",
     "typescript": "^5.7.0",
-    "vite": "^6.0.0",
+    "vite": "^6.4.0",
     "vitest": "^4.0.17"
   },
   "scripts": {