@architect/inventory 2.2.1-RC.0 → 3.0.0-RC.10

package/src/config/pragmas/tables-streams.js

@@ -1,6 +1,7 @@
 let populate = require('./populate-lambda')
 let validate = require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
+let ts = 'tables-streams'
 
 /**
  * `@tables-streams`
@@ -9,8 +10,9 @@ let is = require('../../lib/is')
  *   - If a project has an existing `@tables` Lambda, we'll continue using that so long as the directory exists
  */
 module.exports = function configureTablesStreams ({ arc, inventory, errors }) {
-  if (!arc['tables-streams'] && !arc.tables) return null
-  if (arc['tables-streams'] && !arc.tables) {
+  let tablesStreamsPlugins = inventory.plugins?._methods?.set?.[ts]
+  if (!arc[ts]?.length && !tablesStreamsPlugins?.length && !arc.tables?.length) return null
+  if ((arc[ts] || tablesStreamsPlugins) && !arc.tables) {
     errors.push(`Specifying @tables-streams requires specifying corresponding @tables`)
     return null
   }
@@ -18,12 +20,12 @@ module.exports = function configureTablesStreams ({ arc, inventory, errors }) {
   // Populate @tables
   let tables = arc.tables.filter(t => is.object(t) && t[Object.keys(t)[0]].stream === true)
   if (tables.length) {
-    tables = populate.tables(tables, inventory, errors)
+    tables = populate.tables({ arc, inventory, errors, pragma: tables })
   }
   else tables = null
 
   // Populate @tables-streams
-  let streams = populate['tables-streams'](arc['tables-streams'], inventory, errors)
+  let streams = populate[ts]({ arc, inventory, errors })
 
   if (tables && streams) {
     let uniqueTables = tables.filter(t => !streams.some(s => s.table === t.table))

package/src/config/pragmas/tables.js

@@ -1,4 +1,4 @@
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 let validate = require('./validate')
 
 module.exports = function configureTables ({ arc, errors }) {

package/src/config/pragmas/validate/_events.js

@@ -8,7 +8,7 @@ let { regex, size, unique } = require('./_lib')
  * See: https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-message-metadata.html
  */
 module.exports = function validateEventsAndQueues (pragma, pragmaName, errors) {
-  if (pragma.length) {
+  if (pragma?.length) {
     unique(pragma, pragmaName, errors)
 
     pragma.forEach(event => {

package/src/config/pragmas/validate/_http.js

@@ -1,11 +1,11 @@
 let { unique } = require('./_lib')
-let methods = require('../../../lib/http-methods')
+let { httpMethods } = require('../../../lib')
 
 module.exports = function validateHTTP (http, errors) {
-  if (http.length) {
+  if (http?.length) {
     unique(http, '@http routes', errors)
 
-    let validMethod = str => methods.includes(str.toLowerCase())
+    let validMethod = str => httpMethods.includes(str.toLowerCase())
     let validPath = str => str.match(/^\/[a-zA-Z0-9/\-:._\*]*$/)
     http.forEach(route => {
       let { name, method, path } = route
@@ -49,7 +49,7 @@ module.exports = function validateHTTP (http, errors) {
       let params = path.match(/\/:/g)
       if (params) {
         // Params cannot have non-alphanumeric characters
-        let match = path.match(/\/:[a-zA-Z0-9]+(\/|$)/g)
+        let match = path.match(/\/:[\w.-]+(\/|$)/g)
         if (!match) errors.push(`Invalid @http path (parameters must have only alphanumeric characters): ${name}`)
       }
 

package/src/config/pragmas/validate/_lib.js

@@ -1,15 +1,8 @@
-let is = require('../../../lib/is')
-
-let patterns = {
-  looseName: new RegExp(/^[a-z][a-zA-Z0-9-_]+$/),
-  strictName: new RegExp(/^[a-z][a-z0-9-]+$/),
-  // DynamoDB, SNS, SQS
-  veryLooseName: new RegExp(/^[a-zA-Z0-9/\-._]*$/),
-}
+let { is, validationPatterns } = require('../../../lib')
 
 function regex (value, pattern, pragmaName, errors) {
-  if (!patterns[pattern]) throw ReferenceError(`Invalid validation pattern specified: ${pattern}`)
-  if (!patterns[pattern].test(value)) errors.push(`Invalid ${pragmaName} item: '${value}' must match ${patterns[pattern]}`)
+  if (!validationPatterns[pattern]) throw ReferenceError(`Invalid validation pattern specified: ${pattern}`)
+  if (!validationPatterns[pattern].test(value)) errors.push(`Invalid ${pragmaName} item: '${value}' must match ${validationPatterns[pattern]}`)
 }
 
 function size (value, min, max, pragmaName, errors) {

package/src/config/pragmas/validate/_scheduled.js

@@ -1,4 +1,4 @@
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 let { regex, size, unique } = require('./_lib')
 
 /**
@@ -10,7 +10,7 @@ let { regex, size, unique } = require('./_lib')
  * See: https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html
  */
 module.exports = function validateScheduled (scheduled, errors) {
-  if (scheduled.length) {
+  if (scheduled?.length) {
     unique(scheduled, '@scheduled', errors)
 
     scheduled.forEach(schedule => {

package/src/config/pragmas/validate/_shared.js

@@ -1,5 +1,5 @@
 let { join, resolve, sep } = require('path')
-let is = require('../../../lib/is')
+let { is } = require('../../../lib')
 
 module.exports = function validateShared (src, cwd, errors) {
   let path = src && resolve(join(cwd, src))

package/src/config/pragmas/validate/_tables-streams.js

@@ -7,13 +7,11 @@ let { regex, size, unique } = require('./_lib')
  * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
  */
 module.exports = function validateTablesStreams (tablesStreams, errors) {
-  if (tablesStreams.length) {
-    unique(tablesStreams, '@tables-streams', errors)
+  unique(tablesStreams, '@tables-streams', errors)
 
-    tablesStreams.forEach(stream => {
-      let { name } = stream
-      size(name, 3, 255, '@tables-streams', errors)
-      regex(name, 'veryLooseName', '@tables-streams', errors)
-    })
-  }
+  tablesStreams.forEach(stream => {
+    let { name } = stream
+    size(name, 3, 255, '@tables-streams', errors)
+    regex(name, 'veryLooseName', '@tables-streams', errors)
+  })
 }

package/src/config/pragmas/validate/_tables.js

@@ -2,13 +2,13 @@ let { regex, size, unique } = require('./_lib')
 let { deepStrictEqual } = require('assert')
 
 /**
- * Validate @tables + @indexes
+ * Validate @tables + @tables-indexes
  *
  * Where possible, attempts to follow DynamoDB validation
  * See: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html
  */
 module.exports = function validateTablesAndIndexes (pragma, pragmaName, errors) {
-  if (pragma.length) {
+  if (pragma?.length) {
     pragma.forEach(table => {
       let { name, indexName, partitionKey, sortKey } = table
 

package/src/config/pragmas/validate/index.js

@@ -4,12 +4,12 @@ module.exports = {
   aws:            require('./_aws'),
   events:         require('./_events'),
   http:           require('./_http'),
-  indexes:        require('./_tables'), // Same ruleset as @tables (more or less)
   proxy:          require('./_proxy'),
-  tables:         require('./_tables'),
   queues:         require('./_events'), // Same ruleset as @events
   scheduled:      require('./_scheduled'),
   shared:         require('./_shared'), // Also includes @views
+  tables:         require('./_tables'),
+  tablesIndexes:  require('./_tables'), // Same ruleset as @tables (more or less)
   tablesStreams:  require('./_tables-streams'),
   websockets:     require('./_websockets'),
 

package/src/config/pragmas/views.js

@@ -1,6 +1,6 @@
 let { join } = require('path')
 let validate = require('./validate')
-let is = require('../../lib/is')
+let { is } = require('../../lib')
 
 module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   if (arc.views && !arc.http) {
@@ -9,46 +9,28 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   }
   if (!arc.http) return null
 
-  let cwd = inventory._project.src
-  let src = join(cwd, 'src', 'views')
+  let { cwd, src: projSrc } = inventory._project
+  let src = join(projSrc, 'views')
   let views = {
     src,
     views: [] // Revert to null later if none are defined
   }
 
-  if (arc.views && arc.views.length) {
-    let foundSrc = false
-
-    // First pass to get + check views folder (if any)
+  // First pass to get + check views folder (if any)
+  let foundSrc = false
+  if (arc?.views?.length) {
     for (let view of arc.views) {
-      let key = view[0].toLowerCase()
-      if (key === 'src' && is.string(view[1])) {
-        views.src = view[1]
-        foundSrc = true
-        validate.shared(views.src, cwd, errors)
-      }
-    }
-
-    // Proceeding from here resets all views config, so make sure it's only if specific views are specified
-    let some = !(arc.views.length === 1 && foundSrc)
-    if (some) {
-      // Reset views settings
-      for (let route of pragmas.http) {
-        route.config.views = false
-      }
-
-      // Set new views settings
-      for (let view of arc.views) {
-        let method = view[0].toLowerCase()
-        let path = view[1]
-        if (method === 'src') continue
-        let name = `${method} ${path}`
-        let route = pragmas.http.find(n => n.name === name)
-        if (!route) {
-          return errors.push(`@views ${name} not found in @http routes`)
+      if (is.array(view)) {
+        let key = view[0]?.toLowerCase()
+        if (key === 'src' && is.string(view[1])) {
+          views.src = view[1]
+          foundSrc = true
+          validate.shared(views.src, cwd, errors)
+          continue
+        }
+        if (key === 'src' && !is.string(view[1])) {
+          errors.push(`@shared invalid setting: ${key}`)
         }
-        // Ignore views into ASAP
-        if (!route.arcStaticAssetProxy) route.config.views = true
       }
     }
   }
@@ -56,6 +38,29 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
   // Exit if default views folder doesn't exist
   if (!is.exists(views.src)) return null
 
+  // Proceeding from here resets all views config, so make sure it's only if specific views are specified
+  let some = arc.views?.length && !(arc?.views?.length === 1 && foundSrc)
+  if (some) {
+    // Reset views settings
+    for (let route of pragmas.http) {
+      route.config.views = false
+    }
+
+    // Set new views settings
+    for (let view of arc.views) {
+      let method = view?.[0]?.toLowerCase()
+      let path = view?.[1]
+      if (method === 'src') continue
+      let name = `${method} ${path}`
+      let route = pragmas.http.find(n => n.name === name)
+      if (!route) {
+        return errors.push(`@views ${name} not found in @http routes`)
+      }
+      // Ignore views into ASAP
+      if (!route.arcStaticAssetProxy) route.config.views = true
+    }
+  }
+
   // lambda.config.views was added by Lambda populator defaults, or added above
   for (let { src, config } of pragmas.http) {
     if (config.views === true && !views.views.includes(src)) {
@@ -63,8 +68,5 @@ module.exports = function configureViews ({ arc, pragmas, inventory, errors }) {
     }
   }
 
-  // De-dupe (in case multiple functions live at the same src path)
-  views.views = [ ...new Set(views.views) ]
-
   return views
 }

package/src/config/pragmas/ws.js

@@ -2,21 +2,23 @@ let populate = require('./populate-lambda')
 let validate = require('./validate')
 
 module.exports = function configureWS ({ arc, inventory, errors }) {
-  if (!arc.ws) return null
+  let wsPlugins = inventory.plugins?._methods?.set?.ws
+  if (!arc.ws && !wsPlugins?.length) return null
 
-  let ws = [ ...arc.ws ]
+  let ws = [ ]
+  if (arc.ws) ws.push(...arc.ws)
 
   // Backfill required routes if not already present
   let defaults = [ 'disconnect', 'default', 'connect' ]
   defaults.forEach(route => {
-    let found = arc.ws.find(item => {
+    let found = arc?.ws?.find(item => {
       if (item === route) return true
       if (item[route]) return true
     })
     if (!found) ws.unshift(route)
   })
 
-  let websockets = populate.ws(ws, inventory, errors)
+  let websockets = populate.ws({ arc, inventory, errors, pragma: ws })
 
   // Forgive and normalize userland use of '$default', '$connect', '$disconnect'
   websockets.forEach(({ name }, i) => {

package/src/config/project/index.js

@@ -1,60 +1,76 @@
+let { join } = require('path')
 let upsert = require('../_upsert')
 let prefs = require('./prefs')
-let is = require('../../lib/is')
 let plugins = require('./plugins')
+let { is, mergeEnvVars } = require('../../lib')
 
 /**
  * Get the project-level configuration, overlaying arc.aws settings (if present)
  */
-module.exports = function getProjectConfig (params, errors) {
-  let { arc, raw, filepath, inventory } = params
-  let project = {
+module.exports = function getProjectConfig (params) {
+  let { arc, errors, raw, filepath, inventory } = params
+  let _project = {
     ...inventory._project,
     arc,
     raw,
   }
 
   if (arc.aws) {
-    project.defaultFunctionConfig = upsert(project.defaultFunctionConfig, arc.aws)
+    _project.defaultFunctionConfig = upsert(_project.defaultFunctionConfig, arc.aws)
   }
 
   if (filepath) {
-    project.manifest = filepath
-    // TODO add manifestCreated once we determine we can get birthtime reliably
+    _project.manifest = filepath
   }
 
-  // require project plugin modules
-  project.plugins = plugins(project, errors)
-
-  // parse local and global arc preferences
+  // Parse local and global project preferences
   let scopes = [ 'global', 'local' ]
   for (let scope of scopes) {
     let p = prefs({ scope, inventory, errors })
     if (p) {
       // Set up the scoped metadata
-      project[`${scope}Preferences`] = p.preferences
-      project[`${scope}PreferencesFile`] = p.preferencesFile
+      _project[`${scope}Preferences`] = p.preferences
+      _project[`${scope}PreferencesFile`] = p.preferencesFile
 
       // Build out the final preferences
-      /* istanbul ignore else */ // jic
-      if (!project.preferences) project.preferences = {}
+      /* istanbul ignore else: jic */
+      if (!_project.preferences) _project.preferences = {}
       Object.keys(p.preferences).forEach(pragma => {
         // Ignore the raw data
         if (pragma === '_arc' || pragma === '_raw') return
         // Allow booleans, etc.
         if (!is.object(p.preferences[pragma])) {
-          project.preferences[pragma] = p.preferences[pragma]
+          _project.preferences[pragma] = p.preferences[pragma]
           return
         }
         // Traverse and merge individual settings
-        /* istanbul ignore else */ // jic
-        if (!project.preferences[pragma]) project.preferences[pragma] = {}
+        /* istanbul ignore else: jic */
+        if (!_project.preferences[pragma]) _project.preferences[pragma] = {}
         Object.entries(p.preferences[pragma]).forEach(([ setting, value ]) => {
-          project.preferences[pragma][setting] = value
+          _project.preferences[pragma][setting] = value
         })
       })
     }
   }
 
-  return project
+  // Populate local env from preferences
+  if (_project.preferences?.env) {
+    _project.env.local = _project.preferences.env
+  }
+
+  if (inventory.plugins?._methods) {
+    _project.env.plugins = plugins.env(params, _project)
+    _project.env.local = mergeEnvVars({
+      name: 'Local',
+      source: _project.env.plugins,
+      target: _project.env.local,
+      errors,
+    })
+
+    let { build, runtimes } = plugins.runtimes(params, _project)
+    if (build) _project.build = join(_project.cwd, build)
+    if (runtimes) _project.customRuntimes = runtimes
+  }
+
+  return _project
 }

package/src/config/project/plugins/env.js

@@ -0,0 +1,71 @@
+let { deepFrozenCopy } = require('@architect/utils')
+let { is, tidyError, validationPatterns: valid } = require('../../../lib')
+let envs = [ 'testing', 'staging', 'production' ]
+let str = value => {
+  if (is.object(value) || is.array(value)) return JSON.stringify(value)
+  return String(value)
+}
+
+module.exports = function setEnvPlugins (params, project) {
+  let { errors, inventory } = params
+  let envPlugins = inventory.plugins?._methods?.set?.env
+  if (envPlugins?.length) {
+    let env = {
+      testing: null,
+      staging: null,
+      production: null,
+    }
+
+    // inventory._project is not yet built, so provide as much as we can to plugins for now
+    let inv = deepFrozenCopy({ ...inventory, _project: project })
+    envPlugins.forEach(fn => {
+      let errType = `plugin: ${fn.plugin}, method: set.env`
+      try {
+        let result = fn({ arc: inv._project.arc, inventory: { inv } })
+        if (!is.object(result) || !Object.keys(result).length) {
+          return errors.push(`Env plugin returned invalid data, must return an Object with one or more keys + values: ${errType}`)
+        }
+        // Populate env vars based on environment
+        // If any keys are environment names, disregard all keys except environment names
+        if (Object.keys(result).some(k => envs.includes(k))) {
+          envs.forEach(e => {
+            if (result[e]) Object.entries(result[e]).forEach(([ k, v ]) => {
+              if (!valid.envVar.test(k)) {
+                return errors.push(`Env var '${k}' is invalid, must be [a-zA-Z0-9_]`)
+              }
+              let errored = false, val = str(v)
+              if (!env[e]) env[e] = { [k]: val }
+              else if (env[e][k] && !errored) {
+                errored = true
+                errors.push(`Env var '${k}' already registered: ${errType}`)
+              }
+              else env[e][k] = val
+            })
+          })
+        }
+        // Populate all environments based on env var
+        else {
+          Object.entries(result).forEach(([ k, v ]) => {
+            if (!valid.envVar.test(k)) {
+              return errors.push(`Env var '${k}' is invalid, must be [a-zA-Z0-9_]`)
+            }
+            let errored = false, val = str(v)
+            envs.forEach(e => {
+              if (!env[e]) env[e] = { [k]: val }
+              else if (env[e][k] && !errored) {
+                errored = true
+                errors.push(`Env var '${k}' already registered: ${errType}`)
+              }
+              else env[e][k] = val
+            })
+          })
+        }
+      }
+      catch (err) {
+        errors.push(`Runtime plugin '${fn.plugin}' failed: ${tidyError(err)}`)
+      }
+    })
+    return env
+  }
+  return inventory._project.env.plugins
+}

package/src/config/project/plugins/index.js

@@ -0,0 +1,7 @@
+let env = require('./env')
+let runtimes = require('./runtimes')
+
+module.exports = {
+  env,
+  runtimes,
+}

package/src/config/project/plugins/runtimes.js

@@ -0,0 +1,67 @@
+let { aliases, runtimeList } = require('lambda-runtimes')
+let { deepFrozenCopy } = require('@architect/utils')
+let { is, validationPatterns } = require('../../../lib')
+let { looserName } = validationPatterns
+let allRuntimes = runtimeList.concat([ 'deno', ...Object.keys(aliases) ])
+let validTypes = [ 'transpiled', 'compiled', 'interpreted' ]
+let builtTypes = validTypes.filter(t => t !== 'interpreted')
+
+module.exports = function setRuntimePlugins (params, project) {
+  let { errors, inventory } = params
+  let runtimePlugins = inventory.plugins?._methods?.set?.runtimes
+  if (runtimePlugins?.length) {
+    let runtimes = {
+      runtimes: [],
+    }
+    // inventory._project is not yet built, so provide as much as we can to plugins for now
+    let inv = deepFrozenCopy({ ...inventory, _project: project })
+    let build
+    runtimePlugins.forEach(fn => {
+      let errType = `plugin: ${fn.plugin}, method: set.runtimes`
+      try {
+        var result = fn({ arc: inv._project.arc, inventory: { inv } })
+      }
+      catch (err) {
+        err.message = `Runtime plugin exception: ${errType}`
+                      + `\n` + err.message
+        throw err
+      }
+      // Accept one or more results, then loop through them
+      result = is.array(result) ? result : [ result ]
+      result.forEach(runtime => {
+        let { name, type, baseRuntime } = runtime
+        if (!name || !looserName.test(name)) {
+          let msg = `Runtime plugin must provide a valid name: ${errType}`
+          return errors.push(msg)
+        }
+        if (!type || !validTypes.includes(type)) {
+          let msg = `Runtime plugin must provide a valid type: ${errType}`
+          return errors.push(msg)
+        }
+        if (allRuntimes.includes(name)) {
+          let msg = `Runtime name '${name}' is reserved: ${errType}`
+          return errors.push(msg)
+        }
+        if (runtimes[name]) {
+          let msg = `Runtime name '${name}' already registered: ${errType}`
+          return errors.push(msg)
+        }
+        if (builtTypes.includes(type)) {
+          if (build && runtime.build && build !== runtime.build) {
+            return errors.push(`Runtime '${name}' cannot set a build directory, as it is already configured to: ${build}`)
+          }
+          // Adhere to Postel's Law
+          build = 'build'
+          if (is.string(runtime.build)) build = runtime.build
+        }
+        if (type === 'transpiled' && !allRuntimes.includes(baseRuntime)) {
+          return errors.push(`Runtime '${name}' must include a valid baseRuntime property corresponding to a valid Lambda runtime (e.g. 'nodejs14.x')`)
+        }
+        runtimes.runtimes.push(name)
+        runtimes[name] = runtime
+      })
+    })
+    return { build, runtimes }
+  }
+  return {}
+}

package/src/config/project/prefs/dotenv.js

@@ -0,0 +1,81 @@
+// Copyright (c) 2015, Scott Motte
+// All rights reserved.
+
+/* istanbul ignore file */
+/* eslint-disable */
+// node_modules/dotenv/lib/main.js
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+function parse(src) {
+  const obj = {};
+  let lines = src.toString();
+  lines = lines.replace(/\r\n?/mg, "\n");
+  let match;
+  while ((match = LINE.exec(lines)) != null) {
+    const key = match[1];
+    let value = match[2] || "";
+    value = value.trim();
+    const maybeQuote = value[0];
+    value = value.replace(/^(['"])([\s\S]+)\1$/mg, "$2");
+    if (maybeQuote === '"') {
+      value = value.replace(/\\n/g, "\n");
+      value = value.replace(/\\r/g, "\r");
+    }
+    obj[key] = value;
+  }
+  return obj;
+}
+function _log(message) {
+  console.log(`[dotenv][DEBUG] ${message}`);
+}
+function _resolveHome(envPath) {
+  return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+}
+function config(options) {
+  let dotenvPath = path.resolve(process.cwd(), ".env");
+  let encoding = "utf8";
+  const debug = Boolean(options && options.debug);
+  const override = Boolean(options && options.override);
+  if (options) {
+    if (options.path != null) {
+      dotenvPath = _resolveHome(options.path);
+    }
+    if (options.encoding != null) {
+      encoding = options.encoding;
+    }
+  }
+  try {
+    const parsed = DotenvModule.parse(fs.readFileSync(dotenvPath, { encoding }));
+    Object.keys(parsed).forEach(function(key) {
+      if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
+        process.env[key] = parsed[key];
+      } else {
+        if (override === true) {
+          process.env[key] = parsed[key];
+        }
+        if (debug) {
+          if (override === true) {
+            _log(`"${key}" is already defined in \`process.env\` and WAS overwritten`);
+          } else {
+            _log(`"${key}" is already defined in \`process.env\` and was NOT overwritten`);
+          }
+        }
+      }
+    });
+    return { parsed };
+  } catch (e) {
+    if (debug) {
+      _log(`Failed to load ${dotenvPath} ${e.message}`);
+    }
+    return { error: e };
+  }
+}
+var DotenvModule = {
+  config,
+  parse
+};
+module.exports.config = DotenvModule.config;
+module.exports.parse = DotenvModule.parse;
+module.exports = DotenvModule;