functionalscript 0.1.609 → 0.2.1

package/{com → out/com}/types/module.f.d.mts

@@ -1,8 +1,7 @@
-declare namespace _default {
-    export { paramList };
-    export { result };
-}
-export default _default;
+/** @type {(fa: FieldArray) => list.List<Field> } */
+export const paramList: (fa: FieldArray) => list.List<Field>;
+/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
+export const result: <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T;
 export type Library = { readonly [k in string]: Definition; };
 export type Definition = Struct | Interface;
 export type Struct = {
@@ -20,9 +19,5 @@ export type Type = BaseType | Id | Pointer;
 export type Id = readonly [string];
 export type BaseType = "u8" | "i8" | "u16" | "i16" | "u32" | "i32" | "u64" | "i64" | "usize" | "isize" | "f32" | "f64" | "bool";
 export type Pointer = readonly ["*", Type];
-/** @type {(fa: FieldArray) => List.List<Field> } */
-declare const paramList: (fa: FieldArray) => List.List<Field>;
-/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
-declare const result: <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T;
+import * as list from '../../types/list/module.f.mjs';
 import * as O from '../../types/object/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';

package/out/com/types/module.f.mjs

@@ -0,0 +1,51 @@
+// @ts-self-types="./module.f.d.mts"
+import * as O from '../../types/object/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+import * as f from '../../types/function/module.f.mjs';
+const { compose } = f;
+const { filter } = list;
+const { entries } = Object;
+/** @typedef {{readonly[k in string]: Definition}} Library */
+/** @typedef {Struct|Interface} Definition */
+/**
+ * @typedef {{
+ *  readonly struct: FieldArray
+ * }} Struct
+ */
+/** @typedef {{readonly[k in string]: Type}} FieldArray */
+/** @typedef {O.Entry<Type>} Field */
+/**
+ * @typedef {{
+ *  readonly interface: MethodArray
+ *  readonly guid: string
+ * }} Interface
+ */
+/** @typedef {{readonly[k in string]: FieldArray}} MethodArray */
+/** @typedef {O.Entry<FieldArray>} Method */
+/** @typedef {BaseType|Id|Pointer} Type */
+/** @typedef {readonly[string]} Id */
+/**
+ * @typedef {|
+ *  'u8'|
+ *  'i8'|
+ *  'u16'|
+ *  'i16'|
+ *  'u32'|
+ *  'i32'|
+ *  'u64'|
+ *  'i64'|
+ *  'usize'|
+ *  'isize'|
+ *  'f32'|
+ *  'f64'|
+ *  'bool'
+ * } BaseType
+ */
+/** @typedef {readonly['*', Type]} Pointer */
+/** @type {(kv: O.Entry<Type>) => boolean} */
+const isParam = ([name]) => name !== '_';
+const filterParam = filter(isParam);
+/** @type {(fa: FieldArray) => list.List<Field> } */
+export const paramList = compose(entries)(filterParam);
+/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
+export const result = v => f => fa => '_' in fa ? f(fa._) : v;

package/out/com/types/testlib.f.mjs

@@ -0,0 +1,30 @@
+import * as _ from './module.f.mjs';
+/** @type {_.Library} */
+export default {
+    Slice: {
+        struct: {
+            Start: ['*', 'u8'],
+            Size: 'usize',
+        },
+    },
+    ManagedStruct: {
+        struct: {
+            M: ['IMy']
+        }
+    },
+    IMy: {
+        guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
+        interface: {
+            GetSlice: { _: ['Slice'] },
+            SetSlice: { slice: ['Slice'] },
+            GetUnsafe: { _: ['*', 'bool'] },
+            SetUnsafe: {
+                p: ['*', ['Slice']],
+                size: 'u32'
+            },
+            Some: { p: ['IMy'], _: 'bool' },
+            GetIMy: { a: 'u16', b: 'i16', _: ['IMy'] },
+            SetManagedStruct: { a: ['ManagedStruct'] },
+        },
+    }
+};

package/out/commonjs/build/module.f.d.mts

@@ -0,0 +1,20 @@
+/**
+ * @type {(compile: function_.Compile) =>
+ *  (packageGet: package_.Get) =>
+ *  <M>(moduleMapInterface: module.MapInterface<M>) =>
+ *  (moduleId: module.Id) =>
+ *  (moduleMap: M) =>
+ *  Result<M>
+ * }
+ */
+export const getOrBuild: (compile: function_.Compile) => (packageGet: package_.Get) => <M>(moduleMapInterface: module.MapInterface<M>) => (moduleId: module.Id) => (moduleMap: M) => Result<M>;
+export type Config<M> = {
+    readonly packageGet: package_.Get;
+    readonly moduleMapInterface: module.MapInterface<M>;
+    readonly moduleId: module.Id;
+    readonly moduleMap: M;
+};
+export type Result<M> = readonly [module.State, M];
+import * as function_ from '../module/function/module.f.mjs';
+import * as package_ from '../package/module.f.mjs';
+import * as module from '../module/module.f.mjs';

package/out/commonjs/build/module.f.mjs

@@ -0,0 +1,107 @@
+// @ts-self-types="./module.f.d.mts"
+import * as package_ from '../package/module.f.mjs';
+import * as module from '../module/module.f.mjs';
+const { idToString, dir } = module;
+import * as function_ from '../module/function/module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';
+const { empty: mapEmpty, setReplace } = map;
+import * as object from '../../types/object/module.f.mjs';
+const { fromMap } = object;
+import * as path from '../path/module.f.mjs';
+const { parseAndFind } = path;
+import * as stringSet from '../../types/string_set/module.f.mjs';
+const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet;
+/**
+ * @template M
+ * @typedef {{
+ *  readonly packageGet: package_.Get
+ *  readonly moduleMapInterface: module.MapInterface<M>
+ *  readonly moduleId: module.Id
+ *  readonly moduleMap: M
+ * }} Config
+ */
+/**
+ * @template M
+ * @typedef {readonly[module.State, M]} Result
+ */
+/** @type {<M>(moduleMap: M) => Result<M>} */
+const notFound = moduleMap => [['error', ['file not found']], moduleMap];
+/**
+ * @type {(compile: function_.Compile) =>
+ *  (packageGet: package_.Get) =>
+ *  <M>(moduleMapInterface: module.MapInterface<M>) =>
+ *  (moduleId: module.Id) =>
+ *  (moduleMap: M) =>
+ *  Result<M>
+ * }
+ */
+export const getOrBuild = compile => packageGet => moduleMapInterface => {
+    /** @typedef {typeof moduleMapInterface extends module.MapInterface<infer M> ? M : never} M */
+    /**
+     * @type {(buildSet: stringSet.StringSet) =>
+     *  (moduleId: module.Id) =>
+     *  (source: string) =>
+     *  (moduleMap: M) =>
+     *  Result<M>}
+     */
+    const build = buildSet => moduleId => {
+        const moduleIdStr = idToString(moduleId);
+        const buildSet1 = setSet(moduleIdStr)(buildSet);
+        const moduleDir = dir(moduleId);
+        /** @type {function_.Require<readonly[map.Map<string>, M]>} */
+        const require_ = p => ([requireMap, m]) => {
+            /** @type {(e: unknown) => function_.Result<readonly[map.Map<string>, M]>} */
+            const error = e => [['error', e], [requireMap, m]];
+            if (moduleDir === null) {
+                return error('file not found');
+            }
+            const r = parseAndFind(packageGet)(moduleDir)(p);
+            if (r === null) {
+                return error('file not found');
+            }
+            const rIdStr = idToString(r.id);
+            if (setContains(rIdStr)(buildSet1)) {
+                return error('circular reference');
+            }
+            const [state, m1] = build(buildSet1)(r.id)(r.source)(m);
+            return [state[0] === 'error' ? state : ['ok', state[1].exports], [setReplace(p)(rIdStr)(requireMap), m1]];
+        };
+        return source => moduleMap => {
+            /** @type {(s: module.State) => (m: M) => Result<M>} */
+            const set = s => m => [s, moduleMapInterface.setReplace(moduleIdStr)(s)(m)];
+            /** @type {(e: module.Error) => (m: M) => Result<M>} */
+            const error = e => set(['error', e]);
+            // check compilation
+            const [kind, result] = compile(source);
+            if (kind === 'error') {
+                return error(['compilation error', result])(moduleMap);
+            }
+            // build
+            const [[state, value], [requireMap, moduleMap2]] = result(require_)([mapEmpty, moduleMap]);
+            const x = state === 'error' ?
+                error(['runtime error', value]) :
+                set(['ok', { exports: value, requireMap: fromMap(requireMap) }]);
+            return x(moduleMap2);
+        };
+    };
+    /** @type {(moduleId: module.Id) => (moduleMap: M) => Result<M>} */
+    const f = moduleId => moduleMap => {
+        const moduleIdStr = idToString(moduleId);
+        // check moduleMap
+        {
+            const m = moduleMapInterface.at(moduleIdStr)(moduleMap);
+            if (m !== null) {
+                return [m, moduleMap];
+            }
+        }
+        // check package
+        const p = packageGet(moduleId.package);
+        if (p === null) {
+            return notFound(moduleMap);
+        }
+        // check file
+        const source = p.file(moduleId.path.join('/'));
+        return (source === null ? notFound : build(stringSetEmpty)(moduleId)(source))(moduleMap);
+    };
+    return f;
+};

package/out/commonjs/build/test.f.mjs

@@ -0,0 +1,102 @@
+import * as _ from './module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';
+import * as Module from '../module/module.f.mjs';
+import * as ModuleFunction from '../module/function/module.f.mjs';
+import * as Result from '../../types/result/module.f.mjs';
+import * as Package from '../package/module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { at } = o;
+/** @type {{ readonly [k in string]?: Result.Result<ModuleFunction.Function_, unknown> }} */
+const compileMap = {
+    ':index.js': [
+        'ok',
+        require_ => m0 => {
+            let [r, m] = require_('./b')(m0);
+            if (r[0] === 'error') {
+                throw JSON.stringify(r);
+            }
+            [r, m] = require_('./a/')(m);
+            if (r[0] === 'error') {
+                throw JSON.stringify(r);
+            }
+            [r, m] = require_('x/r')(m);
+            if (r[0] === 'error') {
+                throw JSON.stringify(r);
+            }
+            return [['ok', ':index.js'], m];
+        }
+    ],
+    ':b.js': [
+        'ok',
+        () => m0 => [['ok', ':b.js'], m0]
+    ],
+    ':a/index.js': [
+        'ok',
+        () => m0 => [['ok', ':a/index.js'], m0]
+    ],
+    'x:r.js': [
+        'ok',
+        () => m0 => [['ok', 'x:r.js'], m0]
+    ],
+};
+/** @type {ModuleFunction.Compile} */
+const compile = source => compileMap[source] ?? ['error', 'invalid source'];
+/** @typedef {{ readonly [k in string]: string }} StringMap */
+/** @type {{ readonly [k in string]: { readonly dependencies: StringMap, readonly files: StringMap }}} */
+const packageMap = {
+    '': {
+        dependencies: {
+            'x': '/node_modules/x'
+        },
+        files: {
+            'index.js': ':index.js',
+            'b.js': ':b.js',
+            'a/index.js': ':a/index.js',
+        }
+    },
+    '/node_modules/x': {
+        dependencies: {},
+        files: {
+            'r.js': 'x:r.js'
+        }
+    },
+};
+/** @type {Package.Get} */
+const packageGet = packageId => {
+    const p = at(packageId)(packageMap);
+    return p === null ? null :
+        {
+            dependency: dependency => at(dependency)(p.dependencies),
+            file: file => at(file)(p.files),
+        };
+};
+const getOrBuild = _.getOrBuild(compile)(packageGet)(/** @type {Module.MapInterface<map.Map<Module.State>>} */ (map));
+export default () => {
+    let [r, m] = getOrBuild({ package: '', path: ['index.js'] })(map.empty);
+    {
+        if (r === null) {
+            throw 'r === null';
+        }
+        const x = JSON.stringify(r);
+        if (x !==
+            '["ok",{"exports":":index.js","requireMap":{"./a/":"/a/index.js","./b":"/b.js","x/r":"/node_modules/x/r.js"}}]') {
+            throw `0:${x}`;
+        }
+    }
+    {
+        [r, m] = getOrBuild({ package: '', path: ['b.js'] })(m);
+        const x = JSON.stringify(r);
+        if (x !==
+            '["ok",{"exports":":b.js","requireMap":{}}]') {
+            throw x;
+        }
+    }
+    {
+        [r, m] = getOrBuild({ package: '', path: ['c.js'] })(m);
+        const x = JSON.stringify(r);
+        if (x !==
+            '["error",["file not found"]]') {
+            throw x;
+        }
+    }
+};

package/{commonjs → out/commonjs}/module/function/module.f.d.mts

@@ -1,5 +1,3 @@
-declare const _default: {};
-export default _default;
 export type Function_ = <M>(require: Require<M>) => (prior: M) => Result<M>;
 export type Result<M> = readonly [TypesResult.Result<unknown, unknown>, M];
 export type Require<M> = (path: string) => (prior: M) => Result<M>;

package/out/commonjs/module/function/module.f.mjs

@@ -0,0 +1,15 @@
+// @ts-self-types="./module.f.d.mts"
+/**
+ * An IO interface for creating and running module functions.
+ */
+import * as TypesResult from '../../../types/result/module.f.mjs';
+/** @typedef {<M>(require: Require<M>) => (prior: M) => Result<M>} Function_ */
+/**
+ * @template M
+ * @typedef {readonly[TypesResult.Result<unknown, unknown>, M]} Result
+ */
+/**
+ * @template M
+ * @typedef {(path: string) => (prior: M) => Result<M>} Require
+ */
+/** @typedef {(source: string) => TypesResult.Result<Function_, unknown>} Compile */

package/{commonjs → out/commonjs}/module/module.f.d.mts

@@ -1,22 +1,3 @@
-declare namespace _default {
-    export { dir };
-    export { idToString };
-}
-export default _default;
-export type MapInterface<M> = {
-    readonly at: (moduleId: string) => (moduleMap: M) => State | null;
-    readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M;
-};
-export type State = readonly ["ok", Module] | readonly ["error", Error];
-export type Module = {
-    readonly exports: unknown;
-    readonly requireMap: O.Map<string>;
-};
-export type Error = ["file not found"] | ["compilation error", unknown] | ["runtime error", unknown] | ["circular reference"];
-export type Id = {
-    readonly package: string;
-    readonly path: readonly string[];
-};
 /**
  * @template M
  * @typedef {{
@@ -51,7 +32,21 @@ export type Id = {
  * }} Id
  */
 /** @type {(id: Id) => Id | null} */
-declare const dir: (id: Id) => Id | null;
+export const dir: (id: Id) => Id | null;
 /** @type {(id: Id) => string} */
-declare const idToString: (id: Id) => string;
+export const idToString: (id: Id) => string;
+export type MapInterface<M> = {
+    readonly at: (moduleId: string) => (moduleMap: M) => State | null;
+    readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M;
+};
+export type State = readonly ["ok", Module] | readonly ["error", Error];
+export type Module = {
+    readonly exports: unknown;
+    readonly requireMap: O.Map<string>;
+};
+export type Error = ["file not found"] | ["compilation error", unknown] | ["runtime error", unknown] | ["circular reference"];
+export type Id = {
+    readonly package: string;
+    readonly path: readonly string[];
+};
 import * as O from '../../types/object/module.f.mjs';

package/out/commonjs/module/module.f.mjs

@@ -0,0 +1,48 @@
+// @ts-self-types="./module.f.d.mts"
+import * as O from '../../types/object/module.f.mjs';
+/**
+ * @template M
+ * @typedef {{
+ *  readonly at: (moduleId: string) => (moduleMap: M) => State | null
+ *  readonly setReplace: (moduleId: string) => (moduleState: State) => (moduleMap: M) => M
+ * }} MapInterface
+ */
+/**
+ * @typedef {|
+ *  readonly['ok', Module] |
+ *  readonly['error', Error]
+ * } State
+ */
+/**
+ * @typedef {{
+ *  readonly exports: unknown
+ *  readonly requireMap: O.Map<string>
+ * }} Module
+ */
+/**
+ * @typedef {|
+ *  ['file not found'] |
+ *  ['compilation error', unknown] |
+ *  ['runtime error', unknown] |
+ *  ['circular reference']
+ * } Error
+ */
+/**
+ * @typedef {{
+ *  readonly package: string
+ *  readonly path: readonly string[]
+ * }} Id
+ */
+/** @type {(id: Id) => Id | null} */
+export const dir = id => {
+    const len = id.path.length;
+    if (len < 1) {
+        return null;
+    }
+    return {
+        package: id.package,
+        path: id.path.slice(0, len - 1)
+    };
+};
+/** @type {(id: Id) => string} */
+export const idToString = id => `${id.package}/${id.path.join('/')}`;

package/out/commonjs/module.d.mts

@@ -0,0 +1,3 @@
+/** @type {ModuleFunction.Compile} */
+export const compile: ModuleFunction.Compile;
+import * as ModuleFunction from './module/function/module.f.mjs';

package/{commonjs → out/commonjs}/module.f.d.mts

@@ -1,4 +1,2 @@
-declare const _default: {};
-export default _default;
 export type PackageMap = (packageName: string) => PackageMap | Package | null;
 export type Package = readonly [string, PackageMap, (fileName: string) => string | null];

package/out/commonjs/module.f.mjs

@@ -0,0 +1,10 @@
+// @ts-self-types="./module.f.d.mts"
+export {};
+/** @typedef {(packageName: string) => PackageMap|Package|null} PackageMap */
+/**
+ * @typedef {readonly[
+ *  string,
+ *  PackageMap,
+ *  (fileName: string) => string|null
+ * ]} Package
+ */

package/out/commonjs/module.mjs

@@ -0,0 +1,26 @@
+import unsafeResult from '../types/result/module.mjs';
+const { tryCatch } = unsafeResult;
+import * as result from '../types/result/module.f.mjs';
+const { unwrap } = result;
+import * as ModuleFunction from './module/function/module.f.mjs';
+/** @type {(f: Function) => ModuleFunction.Function_} */
+const build = f => immutableRequire => mutableData => {
+    /** @type {(path: string) => unknown} */
+    const mutableRequire = path => {
+        const [result, data] = immutableRequire(path)(mutableData);
+        // Side effect: setting a variable from a nested function (closure)
+        // is not allowed in FunctionalScript.
+        mutableData = data;
+        return unwrap(result);
+    };
+    const result = tryCatch(() => {
+        const mutableModule = { exports: {} };
+        f(mutableModule, mutableRequire);
+        return mutableModule.exports;
+    });
+    return [result, mutableData];
+};
+/** @type {ModuleFunction.Compile} */
+export const compile = source => 
+// Side effect: a `Function` constructor is not allowed in FunctionalScript.
+tryCatch(() => build(Function('module', 'require', `"use strict";${source}`)));

package/out/commonjs/package/dependencies/module.f.d.mts

@@ -0,0 +1,6 @@
+/** @type {(j: json.Unknown) => j is DependenciesJson} */
+export const isDependenciesJson: (j: json.Unknown) => j is DependenciesJson;
+export type DependencyJson = readonly [string, string];
+export type DependencyMapJson = { readonly [k in string]: string; };
+export type DependenciesJson = DependencyMapJson | null;
+import * as json from '../../../json/module.f.mjs';

package/out/commonjs/package/dependencies/module.f.mjs

@@ -0,0 +1,21 @@
+// @ts-self-types="./module.f.d.mts"
+import * as json from '../../../json/module.f.mjs';
+const { isObject } = json;
+import * as list from '../../../types/list/module.f.mjs';
+const { map, every } = list;
+const { entries } = Object;
+/** @typedef {readonly[string, string]} DependencyJson */
+/** @typedef {{readonly[k in string]: string}} DependencyMapJson */
+/** @typedef {DependencyMapJson|null} DependenciesJson */
+/** @type {(entry: json.Entry) => boolean} */
+const isDependencyJson = ([, v]) => typeof v === 'string';
+/** @type {(j: json.Unknown) => j is DependenciesJson} */
+export const isDependenciesJson = j => {
+    if (j === null) {
+        return true;
+    }
+    if (!isObject(j)) {
+        return false;
+    }
+    return every(map(isDependencyJson)(entries(j)));
+};

package/out/commonjs/package/dependencies/test.f.mjs

@@ -0,0 +1,15 @@
+import * as _ from './module.f.mjs';
+export default () => {
+    if (!_.isDependenciesJson(null)) {
+        throw 'error';
+    }
+    if (!_.isDependenciesJson({})) {
+        throw 'error';
+    }
+    if (!_.isDependenciesJson({ 'a': 'b' })) {
+        throw 'error';
+    }
+    if (_.isDependenciesJson({ 'a': 12 })) {
+        throw 'error';
+    }
+};

package/out/commonjs/package/module.f.d.mts

@@ -0,0 +1,21 @@
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly version: string
+ *  readonly dependencies?: dependencies.DependenciesJson
+ * }} PackageJson
+ */
+/** @type {(j: json.Unknown) => j is PackageJson} */
+export const isPackageJson: (j: json.Unknown) => j is PackageJson;
+export type PackageJson = {
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies?: dependencies.DependenciesJson;
+};
+export type Package = {
+    readonly dependency: (localPackageId: string) => string | null;
+    readonly file: (localFileId: string) => string | null;
+};
+export type Get = (packageId: string) => Package | null;
+import * as json from '../../json/module.f.mjs';
+import * as dependencies from './dependencies/module.f.mjs';

package/out/commonjs/package/module.f.mjs

@@ -0,0 +1,40 @@
+// @ts-self-types="./module.f.d.mts"
+import * as json from '../../json/module.f.mjs';
+const { isObject } = json;
+import * as dependencies from './dependencies/module.f.mjs';
+const { isDependenciesJson } = dependencies;
+import * as o from '../../types/object/module.f.mjs';
+const { at } = o;
+/**
+ * @typedef {{
+ *  readonly name: string
+ *  readonly version: string
+ *  readonly dependencies?: dependencies.DependenciesJson
+ * }} PackageJson
+ */
+/** @type {(j: json.Unknown) => j is PackageJson} */
+export const isPackageJson = j => {
+    if (!isObject(j)) {
+        return false;
+    }
+    if (typeof j.name !== 'string') {
+        return false;
+    }
+    if (typeof j.version !== 'string') {
+        return false;
+    }
+    if (!isDependenciesJson(at('dependencies')(j))) {
+        return false;
+    }
+    return true;
+};
+/**
+ * @typedef {{
+ *  readonly dependency: (localPackageId: string) => string | null
+ *  readonly file: (localFileId: string) => string | null
+ * }} Package
+ */
+/**
+ * @note Current package has an empty string '' as a packageId.
+ * @typedef {(packageId: string) => Package | null} Get
+ */

package/out/commonjs/package/test.f.mjs

@@ -0,0 +1,27 @@
+import * as _ from './module.f.mjs';
+export default () => {
+    if (_.isPackageJson(null)) {
+        throw 'error';
+    }
+    if (_.isPackageJson({})) {
+        throw 'error';
+    }
+    if (_.isPackageJson({ name: 'x', version: 12 })) {
+        throw 'error';
+    }
+    if (!_.isPackageJson({ name: 'x', version: "12" })) {
+        throw 'error';
+    }
+    if (_.isPackageJson({ version: "", dependencies: [] })) {
+        throw 'error';
+    }
+    if (!_.isPackageJson({ name: 'a', version: "", dependencies: {} })) {
+        throw 'error';
+    }
+    if (_.isPackageJson({ name: 'b', version: "", dependencies: { x: 12 } })) {
+        throw 'error';
+    }
+    if (!_.isPackageJson({ name: 'c', version: "", dependencies: { x: "12" } })) {
+        throw 'error';
+    }
+};