tailwindcss 0.0.0-insiders.ea80db2 → 0.0.0-insiders.eae2b7a

package/lib/css/preflight.css

@@ -22,6 +22,8 @@
 2. Prevent adjustments of font size after orientation changes in iOS.
 3. Use a more readable tab size.
 4. Use the user's configured `sans` font-family by default.
+5. Use the user's configured `sans` font-feature-settings by default.
+6. Use the user's configured `sans` font-variation-settings by default.
 */
 
 html {
@@ -30,6 +32,8 @@ html {
   -moz-tab-size: 4; /* 3 */
   tab-size: 4; /* 3 */
   font-family: theme('fontFamily.sans', ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"); /* 4 */
+  font-feature-settings: theme('fontFamily.sans[1].fontFeatureSettings', normal); /* 5 */
+  font-variation-settings: theme('fontFamily.sans[1].fontVariationSettings', normal); /* 6 */
 }
 
 /*
@@ -159,7 +163,10 @@ optgroup,
 select,
 textarea {
   font-family: inherit; /* 1 */
+  font-feature-settings: inherit; /* 1 */
+  font-variation-settings: inherit; /* 1 */
   font-size: 100%; /* 1 */
+  font-weight: inherit; /* 1 */
   line-height: inherit; /* 1 */
   color: inherit; /* 1 */
   margin: 0; /* 2 */
@@ -259,7 +266,7 @@ summary {
 }
 
 /*
-Removes the default spacing and border for appropriate elements.
+Removes the default spacing for appropriate elements.
 */
 
 blockquote,
@@ -295,6 +302,10 @@ menu {
   padding: 0;
 }
 
+dialog {
+  padding: 0;
+}
+
 /*
 Prevent resizing textareas horizontally by default.
 */
@@ -358,10 +369,7 @@ video {
   height: auto;
 }
 
-/*
-Ensure the default browser behavior of the `hidden` attribute.
-*/
-
+/* Make elements with the HTML hidden attribute stay hidden by default */
 [hidden] {
   display: none;
 }

package/lib/featureFlags.js

@@ -2,58 +2,83 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.flagEnabled = flagEnabled;
-exports.issueFlagNotices = issueFlagNotices;
-exports.default = void 0;
-var _picocolors = _interopRequireDefault(require("picocolors"));
-var _log = _interopRequireDefault(require("./util/log"));
-function _interopRequireDefault(obj) {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    featureFlags: function() {
+        return featureFlags;
+    },
+    flagEnabled: function() {
+        return flagEnabled;
+    },
+    issueFlagNotices: function() {
+        return issueFlagNotices;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _picocolors = /*#__PURE__*/ _interop_require_default(require("picocolors"));
+const _log = /*#__PURE__*/ _interop_require_default(require("./util/log"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
 let defaults = {
-    optimizeUniversalDefaults: false
+    optimizeUniversalDefaults: false,
+    disableColorOpacityUtilitiesByDefault: false,
+    relativeContentPathsByDefault: false,
+    oxideParser: true,
+    logicalSiblingUtilities: false
 };
 let featureFlags = {
-    future: [],
+    future: [
+        "hoverOnlyWhenSupported",
+        "respectDefaultRingColorOpacity",
+        "disableColorOpacityUtilitiesByDefault",
+        "relativeContentPathsByDefault",
+        "logicalSiblingUtilities"
+    ],
     experimental: [
-        'optimizeUniversalDefaults'
+        "optimizeUniversalDefaults",
+        "oxideParser"
     ]
 };
 function flagEnabled(config, flag) {
     if (featureFlags.future.includes(flag)) {
-        var ref;
-        var ref1, ref2;
-        return config.future === 'all' || ((ref2 = (ref1 = config === null || config === void 0 ? void 0 : (ref = config.future) === null || ref === void 0 ? void 0 : ref[flag]) !== null && ref1 !== void 0 ? ref1 : defaults[flag]) !== null && ref2 !== void 0 ? ref2 : false);
+        var _config_future;
+        var _config_future_flag, _ref;
+        return config.future === "all" || ((_ref = (_config_future_flag = config === null || config === void 0 ? void 0 : (_config_future = config.future) === null || _config_future === void 0 ? void 0 : _config_future[flag]) !== null && _config_future_flag !== void 0 ? _config_future_flag : defaults[flag]) !== null && _ref !== void 0 ? _ref : false);
     }
     if (featureFlags.experimental.includes(flag)) {
-        var ref3;
-        var ref4, ref5;
-        return config.experimental === 'all' || ((ref5 = (ref4 = config === null || config === void 0 ? void 0 : (ref3 = config.experimental) === null || ref3 === void 0 ? void 0 : ref3[flag]) !== null && ref4 !== void 0 ? ref4 : defaults[flag]) !== null && ref5 !== void 0 ? ref5 : false);
+        var _config_experimental;
+        var _config_experimental_flag, _ref1;
+        return config.experimental === "all" || ((_ref1 = (_config_experimental_flag = config === null || config === void 0 ? void 0 : (_config_experimental = config.experimental) === null || _config_experimental === void 0 ? void 0 : _config_experimental[flag]) !== null && _config_experimental_flag !== void 0 ? _config_experimental_flag : defaults[flag]) !== null && _ref1 !== void 0 ? _ref1 : false);
     }
     return false;
 }
 function experimentalFlagsEnabled(config) {
-    if (config.experimental === 'all') {
+    if (config.experimental === "all") {
         return featureFlags.experimental;
     }
-    var ref;
-    return Object.keys((ref = config === null || config === void 0 ? void 0 : config.experimental) !== null && ref !== void 0 ? ref : {}).filter((flag)=>featureFlags.experimental.includes(flag) && config.experimental[flag]
-    );
+    var _config_experimental;
+    return Object.keys((_config_experimental = config === null || config === void 0 ? void 0 : config.experimental) !== null && _config_experimental !== void 0 ? _config_experimental : {}).filter((flag)=>featureFlags.experimental.includes(flag) && config.experimental[flag]);
 }
 function issueFlagNotices(config) {
     if (process.env.JEST_WORKER_ID !== undefined) {
         return;
     }
     if (experimentalFlagsEnabled(config).length > 0) {
-        let changes = experimentalFlagsEnabled(config).map((s)=>_picocolors.default.yellow(s)
-        ).join(', ');
-        _log.default.warn('experimental-flags-enabled', [
+        let changes = experimentalFlagsEnabled(config).map((s)=>_picocolors.default.yellow(s)).join(", ");
+        _log.default.warn("experimental-flags-enabled", [
             `You have enabled experimental features: ${changes}`,
-            'Experimental features in Tailwind CSS are not covered by semver, may introduce breaking changes, and can change at any time.', 
+            "Experimental features in Tailwind CSS are not covered by semver, may introduce breaking changes, and can change at any time."
         ]);
     }
 }
-var _default = featureFlags;
-exports.default = _default;
+const _default = featureFlags;

package/lib/index.js

@@ -1,41 +1,2 @@
 "use strict";
-var _setupTrackingContext = _interopRequireDefault(require("./lib/setupTrackingContext"));
-var _processTailwindFeatures = _interopRequireDefault(require("./processTailwindFeatures"));
-var _sharedState = require("./lib/sharedState");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-module.exports = function tailwindcss(configOrPath) {
-    return {
-        postcssPlugin: 'tailwindcss',
-        plugins: [
-            _sharedState.env.DEBUG && function(root) {
-                console.log('\n');
-                console.time('JIT TOTAL');
-                return root;
-            },
-            function(root, result) {
-                let context = (0, _setupTrackingContext).default(configOrPath);
-                if (root.type === 'document') {
-                    let roots = root.nodes.filter((node)=>node.type === 'root'
-                    );
-                    for (const root1 of roots){
-                        if (root1.type === 'root') {
-                            (0, _processTailwindFeatures).default(context)(root1, result);
-                        }
-                    }
-                    return;
-                }
-                (0, _processTailwindFeatures).default(context)(root, result);
-            },
-            _sharedState.env.DEBUG && function(root) {
-                console.timeEnd('JIT TOTAL');
-                console.log('\n');
-                return root;
-            }, 
-        ].filter(Boolean)
-    };
-};
-module.exports.postcss = true;
+module.exports = require("./plugin");

package/lib/lib/cacheInvalidation.js

@@ -2,34 +2,57 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.hasContentChanged = hasContentChanged;
-var _crypto = _interopRequireDefault(require("crypto"));
-var sharedState = _interopRequireWildcard(require("./sharedState"));
-function _interopRequireDefault(obj) {
+Object.defineProperty(exports, "hasContentChanged", {
+    enumerable: true,
+    get: function() {
+        return hasContentChanged;
+    }
+});
+const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
+const _sharedState = /*#__PURE__*/ _interop_require_wildcard(require("./sharedState"));
+function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-function _interopRequireWildcard(obj) {
-    if (obj && obj.__esModule) {
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
         return obj;
-    } else {
-        var newObj = {};
-        if (obj != null) {
-            for(var key in obj){
-                if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                    var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};
-                    if (desc.get || desc.set) {
-                        Object.defineProperty(newObj, key, desc);
-                    } else {
-                        newObj[key] = obj[key];
-                    }
-                }
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
             }
         }
-        newObj.default = obj;
-        return newObj;
     }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
 }
 /**
  * Calculate the hash of a string.
@@ -49,21 +72,21 @@ function _interopRequireWildcard(obj) {
  * @param {string} str
  */ function getHash(str) {
     try {
-        return _crypto.default.createHash('md5').update(str, 'utf-8').digest('binary');
+        return _crypto.default.createHash("md5").update(str, "utf-8").digest("binary");
     } catch (err) {
-        return '';
+        return "";
     }
 }
 function hasContentChanged(sourcePath, root) {
     let css = root.toString();
     // We only care about files with @tailwind directives
     // Other files use an existing context
-    if (!css.includes('@tailwind')) {
+    if (!css.includes("@tailwind")) {
         return false;
     }
-    let existingHash = sharedState.sourceHashMap.get(sourcePath);
+    let existingHash = _sharedState.sourceHashMap.get(sourcePath);
     let rootHash = getHash(css);
     let didChange = existingHash !== rootHash;
-    sharedState.sourceHashMap.set(sourcePath, rootHash);
+    _sharedState.sourceHashMap.set(sourcePath, rootHash);
     return didChange;
 }

package/lib/lib/collapseAdjacentRules.js

@@ -2,14 +2,19 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = collapseAdjacentRules;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return collapseAdjacentRules;
+    }
+});
 let comparisonMap = {
     atrule: [
-        'name',
-        'params'
+        "name",
+        "params"
     ],
     rule: [
-        'selector'
+        "selector"
     ]
 };
 let types = new Set(Object.keys(comparisonMap));
@@ -26,12 +31,14 @@ function collapseAdjacentRules() {
                 return;
             }
             let properties = comparisonMap[node.type];
-            var _property, _property1;
-            if (node.type === 'atrule' && node.name === 'font-face') {
+            var _node_property, _currentRule_property;
+            if (node.type === "atrule" && node.name === "font-face") {
                 currentRule = node;
-            } else if (properties.every((property)=>((_property = node[property]) !== null && _property !== void 0 ? _property : '').replace(/\s+/g, ' ') === ((_property1 = currentRule[property]) !== null && _property1 !== void 0 ? _property1 : '').replace(/\s+/g, ' ')
-            )) {
-                currentRule.append(node.nodes);
+            } else if (properties.every((property)=>((_node_property = node[property]) !== null && _node_property !== void 0 ? _node_property : "").replace(/\s+/g, " ") === ((_currentRule_property = currentRule[property]) !== null && _currentRule_property !== void 0 ? _currentRule_property : "").replace(/\s+/g, " "))) {
+                // An AtRule may not have children (for example if we encounter duplicate @import url(…) rules)
+                if (node.nodes) {
+                    currentRule.append(node.nodes);
+                }
                 node.remove();
             } else {
                 currentRule = node;
@@ -43,7 +50,7 @@ function collapseAdjacentRules() {
         // explicitly does not handle rule nesting on its own as
         // the user is expected to use a nesting plugin
         root.each((node)=>{
-            if (node.type === 'atrule') {
+            if (node.type === "atrule") {
                 collapseRulesIn(node);
             }
         });

package/lib/lib/collapseDuplicateDeclarations.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-exports.default = collapseDuplicateDeclarations;
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return collapseDuplicateDeclarations;
+    }
+});
 function collapseDuplicateDeclarations() {
     return (root)=>{
         root.walkRules((node)=>{
@@ -41,8 +46,8 @@ function collapseDuplicateDeclarations() {
             });
             // Drop all the duplicate declarations with the exact same value we've
             // already seen so far.
-            for (let decl1 of droppable){
-                decl1.remove();
+            for (let decl of droppable){
+                decl.remove();
             }
             // Analyze the declarations based on its unit, drop all the declarations
             // with the same unit but the last one in the list.
@@ -58,9 +63,9 @@ function collapseDuplicateDeclarations() {
                     }
                     byUnit.get(unit).add(decl);
                 }
-                for (let declarations1 of byUnit.values()){
+                for (let declarations of byUnit.values()){
                     // Get all but the last one
-                    let removableDeclarations = Array.from(declarations1).slice(0, -1);
+                    let removableDeclarations = Array.from(declarations).slice(0, -1);
                     for (let decl of removableDeclarations){
                         decl.remove();
                     }
@@ -69,12 +74,12 @@ function collapseDuplicateDeclarations() {
         });
     };
 }
-let UNITLESS_NUMBER = Symbol('unitless-number');
+let UNITLESS_NUMBER = Symbol("unitless-number");
 function resolveUnit(input) {
     let result = /^-?\d*.?\d+([\w%]+)?$/g.exec(input);
     if (result) {
-        var ref;
-        return (ref = result[1]) !== null && ref !== void 0 ? ref : UNITLESS_NUMBER;
+        var _result_;
+        return (_result_ = result[1]) !== null && _result_ !== void 0 ? _result_ : UNITLESS_NUMBER;
     }
     return null;
 }

package/lib/lib/content.js

@@ -0,0 +1,207 @@
+// @ts-check
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    parseCandidateFiles: function() {
+        return parseCandidateFiles;
+    },
+    resolvedChangedContent: function() {
+        return resolvedChangedContent;
+    }
+});
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _isglob = /*#__PURE__*/ _interop_require_default(require("is-glob"));
+const _fastglob = /*#__PURE__*/ _interop_require_default(require("fast-glob"));
+const _normalizepath = /*#__PURE__*/ _interop_require_default(require("normalize-path"));
+const _parseGlob = require("../util/parseGlob");
+const _sharedState = require("./sharedState");
+const _oxide = require("@tailwindcss/oxide");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/** @typedef {import('../../types/config.js').RawFile} RawFile */ /** @typedef {import('../../types/config.js').FilePath} FilePath */ /*
+ * @param {import('tailwindcss').Config} tailwindConfig
+ * @param {{skip:string[]}} options
+ * @returns {ContentPath[]}
+ */ function resolveContentFiles(tailwindConfig, { skip =[]  } = {}) {
+    if (Array.isArray(tailwindConfig.content.files) && tailwindConfig.content.files.includes("auto")) {
+        let idx = tailwindConfig.content.files.indexOf("auto");
+        if (idx !== -1) {
+            _sharedState.env.DEBUG && console.time("Calculating resolve content paths");
+            let resolved = (0, _oxide.resolveContentPaths)({
+                base: process.cwd()
+            });
+            _sharedState.env.DEBUG && console.timeEnd("Calculating resolve content paths");
+            tailwindConfig.content.files.splice(idx, 1, ...resolved);
+        }
+    }
+    if (skip.length > 0) {
+        tailwindConfig.content.files = tailwindConfig.content.files.filter((filePath)=>!skip.includes(filePath));
+    }
+    return tailwindConfig.content.files;
+}
+function parseCandidateFiles(context, tailwindConfig) {
+    let files = resolveContentFiles(tailwindConfig, {
+        skip: [
+            context.userConfigPath
+        ]
+    });
+    // Normalize the file globs
+    files = files.filter((filePath)=>typeof filePath === "string");
+    files = files.map(_normalizepath.default);
+    // Split into included and excluded globs
+    let tasks = _fastglob.default.generateTasks(files);
+    /** @type {ContentPath[]} */ let included = [];
+    /** @type {ContentPath[]} */ let excluded = [];
+    for (const task of tasks){
+        included.push(...task.positive.map((filePath)=>parseFilePath(filePath, false)));
+        excluded.push(...task.negative.map((filePath)=>parseFilePath(filePath, true)));
+    }
+    let paths = [
+        ...included,
+        ...excluded
+    ];
+    // Resolve paths relative to the config file or cwd
+    paths = resolveRelativePaths(context, paths);
+    // Resolve symlinks if possible
+    paths = paths.flatMap(resolvePathSymlinks);
+    // Update cached patterns
+    paths = paths.map(resolveGlobPattern);
+    return paths;
+}
+/**
+ *
+ * @param {string} filePath
+ * @param {boolean} ignore
+ * @returns {ContentPath}
+ */ function parseFilePath(filePath, ignore) {
+    let contentPath = {
+        original: filePath,
+        base: filePath,
+        ignore,
+        pattern: filePath,
+        glob: null
+    };
+    if ((0, _isglob.default)(filePath)) {
+        Object.assign(contentPath, (0, _parseGlob.parseGlob)(filePath));
+    }
+    return contentPath;
+}
+/**
+ *
+ * @param {ContentPath} contentPath
+ * @returns {ContentPath}
+ */ function resolveGlobPattern(contentPath) {
+    // This is required for Windows support to properly pick up Glob paths.
+    // Afaik, this technically shouldn't be needed but there's probably
+    // some internal, direct path matching with a normalized path in
+    // a package which can't handle mixed directory separators
+    let base = (0, _normalizepath.default)(contentPath.base);
+    // If the user's file path contains any special characters (like parens) for instance fast-glob
+    // is like "OOOH SHINY" and treats them as such. So we have to escape the base path to fix this
+    base = _fastglob.default.escapePath(base);
+    contentPath.pattern = contentPath.glob ? `${base}/${contentPath.glob}` : base;
+    contentPath.pattern = contentPath.ignore ? `!${contentPath.pattern}` : contentPath.pattern;
+    return contentPath;
+}
+/**
+ * Resolve each path relative to the config file (when possible) if the experimental flag is enabled
+ * Otherwise, resolve relative to the current working directory
+ *
+ * @param {any} context
+ * @param {ContentPath[]} contentPaths
+ * @returns {ContentPath[]}
+ */ function resolveRelativePaths(context, contentPaths) {
+    let resolveFrom = [];
+    // Resolve base paths relative to the config file (when possible) if the experimental flag is enabled
+    if (context.userConfigPath && context.tailwindConfig.content.relative) {
+        resolveFrom = [
+            _path.default.dirname(context.userConfigPath)
+        ];
+    }
+    return contentPaths.map((contentPath)=>{
+        contentPath.base = _path.default.resolve(...resolveFrom, contentPath.base);
+        return contentPath;
+    });
+}
+/**
+ * Resolve the symlink for the base directory / file in each path
+ * These are added as additional dependencies to watch for changes because
+ * some tools (like webpack) will only watch the actual file or directory
+ * but not the symlink itself even in projects that use monorepos.
+ *
+ * @param {ContentPath} contentPath
+ * @returns {ContentPath[]}
+ */ function resolvePathSymlinks(contentPath) {
+    let paths = [
+        contentPath
+    ];
+    try {
+        let resolvedPath = _fs.default.realpathSync(contentPath.base);
+        if (resolvedPath !== contentPath.base) {
+            paths.push({
+                ...contentPath,
+                base: resolvedPath
+            });
+        }
+    } catch  {
+    // TODO: log this?
+    }
+    return paths;
+}
+function resolvedChangedContent(context, candidateFiles, fileModifiedMap) {
+    let changedContent = context.tailwindConfig.content.files.filter((item)=>typeof item.raw === "string").map(({ raw , extension ="html"  })=>({
+            content: raw,
+            extension
+        }));
+    let [changedFiles, mTimesToCommit] = resolveChangedFiles(candidateFiles, fileModifiedMap);
+    for (let changedFile of changedFiles){
+        let extension = _path.default.extname(changedFile).slice(1);
+        changedContent.push({
+            file: changedFile,
+            extension
+        });
+    }
+    return [
+        changedContent,
+        mTimesToCommit
+    ];
+}
+/**
+ *
+ * @param {ContentPath[]} candidateFiles
+ * @param {Map<string, number>} fileModifiedMap
+ * @returns {[Set<string>, Map<string, number>]}
+ */ function resolveChangedFiles(candidateFiles, fileModifiedMap) {
+    let paths = candidateFiles.map((contentPath)=>contentPath.pattern);
+    let mTimesToCommit = new Map();
+    let changedFiles = new Set();
+    _sharedState.env.DEBUG && console.time("Finding changed files");
+    let files = _fastglob.default.sync(paths, {
+        absolute: true
+    });
+    for (let file of files){
+        let prevModified = fileModifiedMap.get(file) || -Infinity;
+        let modified = _fs.default.statSync(file).mtimeMs;
+        if (modified > prevModified) {
+            changedFiles.add(file);
+            mTimesToCommit.set(file, modified);
+        }
+    }
+    _sharedState.env.DEBUG && console.timeEnd("Finding changed files");
+    return [
+        changedFiles,
+        mTimesToCommit
+    ];
+}