@sap/cds-dk 9.9.2 → 10.0.3

package/node_modules/@sap/cds/eslint.config.mjs

@@ -0,0 +1,153 @@
+import eslint_js from '@eslint/js'
+
+/**
+ * Makes the eslint config object available for external use.
+ */
+export const eslint = eslint_js.configs
+
+/**
+ * Recommended ESLint config for @sap/cds projects.
+ */
+export const defaults = { name: '@cap/eslint/defaults',
+
+  rules: {
+    'no-unused-vars': 'warn',
+    'no-console': 'warn',
+  },
+
+  languageOptions: {
+    ecmaVersion: 2024,
+    globals: {
+
+      // cds.ql commands ...
+      SELECT: 'readonly',
+      INSERT: 'readonly',
+      UPSERT: 'readonly',
+      UPDATE: 'readonly',
+      DELETE: 'readonly',
+      CREATE: 'readonly',
+      DROP: 'readonly',
+
+      // tagged template strings ...
+      CDL: 'readonly',
+      CQL: 'readonly',
+      CXL: 'readonly',
+
+      // subset of Node.js globals ...
+      __filename: 'readonly',
+      __dirname: 'readonly',
+      exports: 'writable',
+      require: 'readonly',
+      global: 'readonly',
+      module: 'readonly',
+      console: 'readonly',
+      process: 'readonly',
+      performance: 'readonly',
+      setImmediate: 'readonly',
+      setInterval: 'readonly',
+      setTimeout: 'readonly',
+      clearImmediate: 'readonly',
+      clearInterval: 'readonly',
+      clearTimeout: 'readonly',
+      structuredClone: 'readonly',
+      atob: 'readonly',
+      btoa: 'readonly',
+
+      AbortController: 'readonly',
+      AbortSignal: 'readonly',
+      Buffer: 'readonly',
+      fetch: 'readonly',
+      Headers: 'readonly',
+      Request: 'readonly',
+      Response: 'readonly',
+      ReadableStream: 'readonly',
+      WritableStream: 'readonly',
+      URL: 'readonly',
+      URLSearchParams: 'readonly',
+    }
+  },
+
+  linterOptions: {
+    reportUnusedDisableDirectives: false,
+  }
+}
+
+/**
+ * ESLint config for jest and mocha test.
+ */
+export const tests = { name: '@cap/eslint/tests',
+  files: [ '**/+(test|tests)/**/*.+(js|cjs|mjs)', '**/*.test.+(js|cjs|mjs)', '**/*-test.+(js|cjs|mjs)' ],
+  languageOptions: {
+    globals: {
+      mocha: 'readonly',
+      jest: 'readonly',
+      expect: 'readonly',
+      describe: 'writable',
+      xdescribe: 'writable',
+      context: 'writable',
+      suite: 'writable',
+      test: 'writable', xtest: 'writable',
+      it: 'writable',
+      fail: 'writable',
+      before: 'readonly',
+      after: 'readonly',
+      beforeAll: 'readonly',
+      afterAll: 'readonly',
+      beforeEach: 'readonly',
+      afterEach: 'readonly',
+    }
+  },
+}
+
+/**
+ * ESLint config for code running in web browsers.
+ */
+export const browser = { name: '@cap/eslint/browser',
+  files: [ '**/app/**/*.js', '**/webapp/**/*.js' ],
+  languageOptions: {
+    globals: {
+      window: 'readonly',
+      history: 'readonly',
+      document: 'readonly',
+      location: 'writeable',
+      localStorage: 'readonly',
+      sessionStorage: 'readonly',
+      parent: 'readonly',
+      event: 'readonly',
+      sap: 'readonly',
+    }
+  },
+}
+
+/**
+ * Global ignores for all configs.
+ */
+export const ignores = {
+  name: '@cap/eslint/ignores',
+  ignores: [
+    '**/@cds-models/',
+    // '**/webapp/**',
+  ]
+}
+
+/**
+ * Recommended all-in-one config for external eslint use, i.e. in cap/dev
+ * monorepo, other cap impl projects, as well as in cap-based projects.
+ * Currently the same as internal, could differ in the future.
+ */
+export const recommended = [
+  eslint.recommended,
+  defaults,
+  browser,
+  tests,
+  ignores,
+]
+
+/**
+ * Default export is for internal use in @sap/cds and cap/dev projects.
+ * It adds additional ignores, e.g. for peggy-generated parser code.
+ */
+export default Object.assign ([ ...recommended,
+  { files: ['bin/*.js'], rules: { 'no-console': 'off' } },
+  { ignores:[ '**/libx/odata/parse/parser.js' ] },
+], { recommended, defaults, browser, tests, ignores })

package/node_modules/@sap/cds/lib/compile/cds-compile.js

@@ -0,0 +1,63 @@
+/**
+ * This is the central API facade to call compiler functions.
+ */
+const compile = module.exports = Object.assign (cds_compile, {
+
+  for: new class {
+    get java(){ return super.java = require('./for/java') }
+    get nodejs() { return super.nodejs = require('./for/nodejs') }
+    get direct_crud() { return super.direct_crud = require('./for/direct_crud') }
+    get lean_drafts() { return super.lean_drafts = require('./for/lean_drafts') }
+    get flows() { return super.flows = require('./for/flows') }
+    get assert() { return super.assert = require('./for/assert') }
+    get odata() { return super.odata = require('./for/odata') }
+    get sql() { return super.sql = require('./for/sql') }
+  },
+
+  to: new class {
+    get csn() { return super.csn = require('./to/csn') }
+    get cdl() { return super.cdl = require('./to/cdl') }
+    get yml() { return super.yml = require('./etc/yaml').stringify }
+    get yaml() { return super.yaml = require('./etc/yaml').stringify }
+    get json() { return super.json = require('./to/json') }
+    get edm() { return super.edm = require('./to/edm') }
+    get edmx() { return super.edmx = compile.to.edm.x }
+    get sql() { return super.sql = require('./to/sql') }
+    get hdbtable() { return super.hdbtable = compile.to.sql.hdbtable }
+    get hana() { return super.hana = compile.to.sql.hana }
+    get hdbtabledata() { return super.hdbtabledata = require('./to/hdbtabledata') }
+    get serviceinfo() { return super.serviceinfo = require('./to/srvinfo') } //> REVISIT: move to CLI
+  },
+
+})
+
+
+
+/**
+ * This is the central frontend function to compile sources to CSN.
+ * @param {string|string[]|{}} model one of:
+ * - a single filename starting with 'file:'
+ * - a single CDL source string
+ * - an object with multiple CDL or CSN sources
+ * - an array of one or more filenames
+ * @param { _flavor | {flavor:_flavor, ...}} options
+ * - an options object or a string specifying the flavor of CSN to generate
+ * @param { 'inferred'|'xtended'|'parsed' } _flavor - for internal use only(!)
+ * @returns {{ namespace?:string, definitions:{}, extensions?:[], meta:{ flavor:_flavor }}} CSN
+ */
+function cds_compile (model, options, _flavor) {
+  const csn = compile.to.csn (model, options, _flavor)
+  return Object.defineProperties (csn, { // fluent
+    for : {configurable:true, get:()=> new Proxy ({api:compile.for,csn},_handlers)},
+    to  : {configurable:true, get:()=> new Proxy ({api:compile.to, csn},_handlers)},
+  })
+}
+
+const _handlers = {
+  ownKeys: ({api}) => Reflect.ownKeys (api),
+  get: ({api,csn},p) => {
+    delete csn.for; delete csn.to //> cleanup the decorated CSN or Promise
+    let fn = api[p]; if (!fn) return
+    return o => 'then' in csn ? csn.then(m => fn(m,o)) : fn(csn,o)
+  }
+}

package/node_modules/@sap/cds/lib/compile/cdsc.js

@@ -0,0 +1,166 @@
+const cds = require ('../index')
+const compile = require ('@sap/cds-compiler')
+const _4cdsc = Symbol('_4cdsc')
+
+/**
+ * Returns a copy of the given options object, with all mappings applied and
+ * finally overridden with entries from cds.env.cdsc. That is, the equivalent
+ * of {...o, ...[...mappings], ...cds.env.cdsc }.
+ * @type <T> (src:T,...mappings:{}[]) => T
+ */
+function _options4 (src, ...mappings) {
+  if (src[_4cdsc]) return src //> already prepared for cdsc
+  // Create a derivate of given src options object
+  const dst = Object.defineProperty({__proto__:src, ...src}, _4cdsc,{value:true}) // NOTE: {__proto__:src} alone doesn't suffice, due to compiler obviously cloning options; {...src} doesn't suffice as non-enumerables from .effective.odata would get lost
+  // Apply mappings in order of appearance -> latter ones override formers
+  for (let map of mappings) for (let k in map) {
+    let v = dst[k];  if (v === undefined) continue
+    let m = map[k];  if (typeof m === 'function') m(dst,v); else dst[m] = v
+  }
+
+  dst.draftMessages ??= cds.env.fiori.draft_messages // REVISIT: Is this the appropriate way to forward config to compiler?
+
+  // Optionally add .messages array to avoid compiler writing messages to stderr
+  dst.messages = dst.messages || []
+  // Finally override with options from cds.env.cdsc
+  return Object.assign(dst,cds.env.cdsc)
+}
+
+
+/**
+ * Decorates the _options4 function with individual options mapping functions
+ * for use in respective calls to cdsc functions. Can be used as follows:
+ *
+ *     const {_options} = require(<this module>)   // from external
+ *     _options.for.odata({...})                   // same in here
+ */
+const _options = {for: Object.assign (_options4, {
+
+  odata(o,_more) {
+    const odata = cds.env.odata
+    if (o && o[_4cdsc]) return o
+    let f = o && o.flavor || odata.flavor || o, flavor = odata.flavors && odata.flavors[f] || {}
+    let v = o && o.version || flavor.version || odata.version   //> env.odata.flavors.version overrides env.odata.version!
+    let o2 = { ...flavor, ...odata, ...o, version:v }
+    if (o2.refs && o2.proxies === undefined) o2.proxies = true  //> o.proxies follows o.refs
+    o2.names = this.sql().names
+    return _options4 (o2, {
+      version     : 'odataVersion',
+      structs     : (o,v) => o.odataFormat = v ? 'structured' : 'flat',
+      refs        : (o,v) => o.odataForeignKeys = !v,
+      xrefs       : 'odataXServiceRefs',
+      proxies     : 'odataProxies',
+      containment : 'odataContainment',
+      // IMPORTANT: as a matter of fact we need the below not only for .to.sql tasks
+      sql_mapping  : 'names', //> legacy
+      names        : (o,v) => v !== 'plain' ? o.sqlMapping = v : undefined,
+    }, _more)
+  },
+
+  edm(o) {
+    return this.odata (o, {
+      version : 'odataVersion',
+      service : 'service',
+    })
+  },
+
+  sql (_o, _env, _conf = cds.requires.db) {
+    // REVISIT: compiler requires to only provide assertIntegrityType if defined
+    if (_o?._4sql) return _o
+    const o = _options4 ({ ..._env||cds.env.sql, ..._o, _4sql: true }, {
+      sql_mapping  : 'names', //> legacy
+      sqlDialect   : 'dialect', //> legacy
+      sqlMapping   : 'names',
+      dialect      : 'sqlDialect',
+      names        : (o,v) => v !== 'plain' ? o.sqlMapping = v : undefined,
+    })
+
+    if (!o.sqlDialect) {
+      let conf = _conf || cds.requires.kinds.sql
+      let dialect = conf.dialect || conf.kind
+      if (dialect) o.sqlDialect = dialect
+    }
+
+    if (_conf?.decimal_affinity) o.decimal_affinity = _conf.decimal_affinity
+
+    const _using_legacy_db = (()=>{
+      if (_conf?.impl) return _conf.impl.includes('@sap/cds/libx/_runtime/')
+      if (cds.requires.kinds.sqlite.impl === '@cap-js/sqlite') return false
+      else try { return require('sqlite3', { paths:[cds.root] }) } catch {/* ignore */}
+    })()
+    if (_using_legacy_db) {
+      o.betterSqliteSessionVariables = false
+    }
+
+    const { native_hana_associations } = cds.env.sql
+    if (native_hana_associations !== undefined)
+      o.withHanaAssociations = native_hana_associations
+
+    const { assert_integrity } = cds.env.features
+    if (assert_integrity)
+      o.assertIntegrityType = assert_integrity.toString().toUpperCase()
+
+    return o
+  },
+
+  hana(o) {
+    let cdsc = this.sql (o, cds.env.hana, cds.requires.kinds.hana) // returns clone
+    cdsc.sqlChangeMode ??= cdsc.journal && cdsc.journal['change-mode']
+    cdsc.disableHanaComments ??= !cdsc.comments
+    delete cdsc.journal // cleanup avoiding side effects
+    delete cdsc.comments
+    return cdsc
+  },
+
+  env() {
+    const odata = this.edm()
+    const sql   = this.sql()
+    const hana  = this.hana()
+    const env = {
+      odata: odata.__proto__,
+      sql:   sql.__proto__,
+      hana:  hana.__proto__,
+      cdsc: { ...odata, ...sql, ...hana }
+    }
+    delete env.odata.flavors
+    return env
+  },
+
+})}
+
+
+/**
+ * Return a derivate of cdsc, with the most prominent
+ * @type { import('@sap/cds-compiler') }
+ */
+module.exports = exports = {__proto__:compile, _options,
+  for: {__proto__: compile.for,
+    odata: (csn,o) => compile.for.odata  (csn, _options.for.odata(o)),
+  },
+  to: {__proto__: compile.to,
+    edmx: Object.assign ((csn,o) => compile.to.edmx (csn, _options.for.edm(o)), {
+      all: (csn,o) => compile.to.edmx.all (csn, _options.for.edm(o))
+    }),
+    edm: Object.assign ((csn,o) => compile.to.edm (csn, _options.for.edm(o)), {
+      all: (csn,o) => compile.to.edm.all (csn, _options.for.edm(o))
+    }),
+    hdi: Object.assign ((csn,o) => compile.to.hdi (csn, _options.for.hana(o)),
+      compile.to.hdi, // keywords
+      {
+        migration: (csn,o,...etc) => {
+          o = Object.assign ({...o},_options.for.hana(o)) //> REVISIT: need to flatten as compiler seems to clone options in that impl
+          return compile.to.hdi.migration (csn, o, ...etc)
+        }
+      },
+    ),
+    sql: Object.assign(
+      (csn,o) => compile.to.sql (csn, _options.for.sql(o)),
+      compile.to.sql // smart* functions
+    ),
+    deltaSql: (csn, o, beforeCsn) => compile.to.sql.migration(csn, o, beforeCsn), // or like hdi.migration
+    cdl: Object.assign(
+      (csn,o) => compile.to.cdl (csn, _options4(o||{})),
+      compile.to.cdl // smart* functions
+    ),
+  },
+}

package/node_modules/@sap/cds/lib/compile/etc/_localized.js

@@ -0,0 +1,75 @@
+const cds = require('../..')
+const DEBUG = cds.debug('alpha|_localized')
+const _been_here = Symbol('is _localized')
+
+
+
+/**
+ * In case of old SQLite service, for each localized_<view> we get from the
+ * compiler, create additional views localized_<locale>_<views>
+ */
+function unfold_ddl (ddl) {
+	return ddl
+}
+
+
+
+/**
+ * Add localized. entries and localized.<locale> entries (as in compiler v1) to reflect what
+ * For each localized.<view> we get from the compiler, ensure there's a
+ * corresponding localized.<locale>. entry in the model to support reflection.
+ * In addition
+ */
+function unfold_csn (m) {
+
+	// only do that once per model
+	if (!m || m[_been_here]) return m
+	DEBUG && DEBUG ('unfolding csn...')
+	const pass2 = []
+
+	// Pass 1 - add localized.<locale> entities and views
+	for (const each in cds.linked(m).definitions) {
+		const d = m.definitions [each]
+		// Add localized.<entry> for all entities having localized views in db
+		if (_is_localized(d)) {
+			_add_proxy4 (d,`localized.${each}`, x => pass2.push([x]))
+			// if running on sqlite add additional localized.<locale>. views
+		}
+	}
+
+	// Pass 2 - redirect associations/compositions in elements to localized.<locale> targets
+	for (const [x,locale] of pass2) {
+		let overlayed = null
+		for (const each in x.elements) {
+			const e = x.elements [each]
+			if (e._target && _is_localized(e._target)) {
+				const elements = overlayed ??= x.elements = {__proto__:x.elements}
+				const target = locale ? `localized.${locale}.${e.target}` : `localized.${e.target}`
+				const _target = m.definitions[target]
+				if (_target) {
+					elements[each] = Object.defineProperty ({__proto__:e,target},'_target',{value:_target})
+					DEBUG && DEBUG ('overriding:', each, ':', elements[each], 'in', { entity: x.name })
+				}
+				else DEBUG && DEBUG ('NOT!! overriding:', each, ':', elements[each], 'in', { entity: x.name })
+			}
+		}
+	}
+
+	// done
+	DEBUG && pass2.length && DEBUG ('Added localized views for sqlite to csn for', m.$sources)
+	return Object.defineProperty (m, _been_here, {value:true})
+
+	function _add_proxy4 (d, name, callback) {
+		if (name in m.definitions) return DEBUG && DEBUG ('NOT overriding existing:', name)
+		const x = {__proto__:d, name };   DEBUG && DEBUG ('adding proxy:', x)
+		if (d['@cds.persistence.name']) x['@cds.persistence.name'] = `localized.${d['@cds.persistence.name']}`
+		Object.defineProperty (m.definitions, name, {value:x,writable:true,configurable:true})
+		if (callback) callback(x)
+	}
+}
+
+
+const _is_localized = d => d.own('$localized') // as set by compiler in compile.for.odata
+
+// feature-toggled exports
+module.exports = { unfold_csn, unfold_ddl }

package/node_modules/@sap/cds/lib/compile/etc/csv.js

@@ -0,0 +1,87 @@
+const { readFileSync } = require ('fs')
+
+const SEPARATOR = /[,;\t]/
+const CSV = module.exports = { read, parse }
+
+function read (res, options) {
+  try {
+    const lines = CSV.parse (readFileSync (res, 'utf-8'))
+    if (options === 'objects') {
+      const [ header, ...rows ] = lines
+      return rows.map (row => header.reduce ((o, k, i) => (o[k] = row[i], o), {}))
+    }
+    else return lines
+  } catch (e) {
+    // eslint-disable-next-line preserve-caught-error
+    if (e.code !== 'ENOENT') throw new Error (`Corrupt .csv file: ${res}.csv`)
+  }
+}
+
+function parse (csv) {
+  if (csv[0] === BOM)  csv = csv.slice(1)
+  let sep
+  // this also means that \r\n within quotes is NOT retained but normalized to \n.  We accept this for now.
+  const lines = csv.split(/\r?\n/)
+  const rows = [], headers = []
+
+  let val, values=[]
+  let inString=false, quoted=false
+  for (let l = 0; l < lines.length; l++) {
+    const line = lines[l]
+    if (!rows.length && _ignoreLine (line))  continue
+    if (!sep)  [sep] = SEPARATOR.exec(line)||[';']
+    if (inString)  val += '\n' // overflow from last line
+    else val = undefined
+
+    let currCol=0, c
+    for (let i=0; i<line.length; ) {
+      c = line[i++]
+      if (c === sep && !inString) {  // separator
+        currCol++
+        if (!rows.length && val !== undefined)  headers.push (currCol)     // skip column if header value is empty
+        if (headers.includes(currCol))  values.push (_value4(val, quoted)) // skip value if column was skipped
+        val = undefined, quoted = false //> start new val
+      }
+      else if (c === ' ' && val === undefined) {
+        // ignore leading spaces
+        continue
+      }
+      else if (c === '"' && val === undefined) { // start quoted string
+        val = ''
+        inString = true
+      }
+      else if (c === '"' && inString) { // within quoted string
+        if (line[i] === '"')  val += line[i++]  // escape quote:  "" > "
+        else inString = false, quoted = true // stop string
+      }
+      else {  // normal char
+        val ??= ''
+        val += c
+      }
+    }
+
+    // finish line w/ remaining value
+    if (!inString || l === lines.length-1 ) { // unless unterminated string and more lines to come
+      currCol++
+      if (!rows.length && val !== undefined)  headers.push(currCol)  // skip column if header value is empty
+      if ((val !== undefined || c === sep) && headers.includes(currCol))  values.push (_value4(val, quoted))
+      if (values.length > 0)  { rows.push (values); values = [] }
+    }
+  }
+  return rows
+}
+
+const globals = { null:null, true:true, false:false }
+function _value4 (val, quoted) {
+  if (quoted)  return val
+  if (val) val = val.trim(); else return undefined
+  if (val in globals) return globals[val] //> null, true, false
+  let n = Number(val)
+  return n.toString() == val ? n : val
+}
+
+function _ignoreLine(line) {
+  return line[0] === '#' || !line.trim().length
+}
+
+const BOM = '\ufeff'

package/node_modules/@sap/cds/lib/compile/etc/properties.js

@@ -0,0 +1,44 @@
+const path = require('path')
+const fs = require('fs')
+
+exports.read = function read (res, ext = '.properties', options) {
+  try {
+    // Although properties are actually latin1-encoded, people tend to have
+    // unicode chars in them (e.g.German umlauts), so let's parse in utf-8.
+    if (!/\.(env|.+rc)$/.test(res) && !path.extname(res)) res += ext
+    const src = fs.readFileSync(path.resolve(res),'utf-8')
+    return Object.defineProperty (exports.parse(src,options), '_source', {value:res})
+  } catch (e) {
+    // eslint-disable-next-line preserve-caught-error
+    if (e.code !== 'ENOENT') throw new Error (`Corrupt ${ext} file: ${res+ext}`)
+  }
+}
+
+exports.parse = function parse (props, options) {
+  if (props.match(/^\s*{/)) return JSON.parse(props)
+  const lines = props.split(/(?<![\\\r])\r?\n/)
+  const rows = lines.filter(each => !!each.trim()).map(each => each.replace(/\\\r?\n/, '')).map(each => {
+    const index = each.indexOf('=')
+    if (index < 0)  return [each, '']
+    return [each.slice(0, index).trim(), each.slice(index + 1).trim()]
+  })
+  const val = options?.strings ? string4 : value4
+  const bundle = rows.reduce((all, [key, value]) => {
+    if (key && !/^\s*[#;]/.test(key)) all[key] = val(value)
+    return all
+  }, {})
+  return bundle
+}
+
+function value4 (raw) {
+  if (raw === 'true') return true
+  if (raw === 'false') return false
+  if (raw === '0') return 0
+  else return Number(raw) || string4(raw)
+}
+
+function string4 (raw) {
+  return raw
+  .replace(/''/g,"'") .replace(/^"(.*)"$/,"$1") .replace(/^'(.*)'$/,"$1")
+  .replace(/\\u[\dA-F]{4}/gi, (match) => String.fromCharCode(parseInt(match.replace(/\\u/g, ''), 16)))
+}

package/node_modules/@sap/cds/lib/compile/etc/yaml.js

@@ -0,0 +1,9 @@
+const { LinkedDefinitions } = require ('../../core/linked-csn')
+const { readFileSync } = require('fs')
+const YAML = require ('yaml')
+
+module.exports = {
+  read: (file) => YAML.parse (readFileSync(file,'utf-8'), { filename: file }),
+  parse: YAML.parse,
+  stringify: (x,o) => YAML.stringify (x, (_,v) => v instanceof LinkedDefinitions ? {...v} : v, o),
+}

package/node_modules/@sap/cds/lib/compile/extend.js

@@ -0,0 +1,39 @@
+const cds = new class { get compile(){ return super.compile = require ('./cds-compile') }}
+const extend = require ('../utils/extend')
+
+/** @type <T> (target:T) => ({
+  with <X,Y,Z> (x:X, y:Y, z:Z): ( T & X & Y & Z )
+  with <X,Y> (x:X, y:Y): ( T & X & Y )
+  with <X> (x:X): ( T & X )
+}) */
+module.exports = o => o.definitions ? { with(...csns) {
+
+    // merge all extension csns
+    const csn=o, merged = { definitions: {}, extensions: [] }
+    for (const { definitions, extensions } of csns) {
+      if (definitions) Object.assign(merged.definitions, definitions)
+      if (extensions) merged.extensions.push(...extensions)
+    }
+
+    // extend given base csn with merged extensions
+    const extended = cds.compile({
+      'base.csn': cds.compile.to.json(csn),
+      'ext.csn': cds.compile.to.json(merged)
+    })
+
+    // handle localized extension elements
+    for (let ext of merged.extensions) {
+      for (let name in ext.elements) {
+        const e = ext.elements[name]
+        if (e.localized) {
+          // add localized element also to respective .texts entity
+          const texts = extended.definitions[ext.extend+'.texts']
+          texts.elements[name] ??= { ...e, localized:null }
+        }
+      }
+    }
+
+    extended.$sources = csn.$sources // required to load resources like i18n later on
+    return extended
+
+}} : extend(o)