@powerlines/deepkit 0.5.0 → 0.5.1

package/dist/{chunk-YKFG2BZQ.cjs → vendor/chunk-5NPGWGPO.cjs}

@@ -1,9 +1,6 @@
 'use strict';
 
-var chunkWVKPC33H_cjs = require('./chunk-WVKPC33H.cjs');
-
 // ../../node_modules/.pnpm/@deepkit+type-spec@1.0.1_patch_hash=f3c3a4fd486751022d78f17d39a5a79f493bca20b185964ca1aba41fbfc93244/node_modules/@deepkit/type-spec/dist/esm/src/type.js
-chunkWVKPC33H_cjs.init_cjs_shims();
 exports.TypeNumberBrand = void 0;
 (function(TypeNumberBrand2) {
   TypeNumberBrand2[TypeNumberBrand2["integer"] = 0] = "integer";
@@ -110,6 +107,3 @@ exports.ReflectionOp = void 0;
   ReflectionOp2[ReflectionOp2["nominal"] = 88] = "nominal";
   ReflectionOp2[ReflectionOp2["tags"] = 89] = "tags";
 })(exports.ReflectionOp || (exports.ReflectionOp = {}));
-
-// ../../node_modules/.pnpm/@deepkit+type-spec@1.0.1_patch_hash=f3c3a4fd486751022d78f17d39a5a79f493bca20b185964ca1aba41fbfc93244/node_modules/@deepkit/type-spec/dist/esm/index.js
-chunkWVKPC33H_cjs.init_cjs_shims();

package/dist/vendor/{chunk-BLN7QVCP.js → chunk-7LAB3COT.js}

@@ -1,147 +1,6 @@
-import { __commonJS, __name, __toESM } from './chunk-5BKT4CS5.js';
-
-// ../../node_modules/.pnpm/is-obj@2.0.0/node_modules/is-obj/index.js
-var require_is_obj = __commonJS({
-  "../../node_modules/.pnpm/is-obj@2.0.0/node_modules/is-obj/index.js"(exports$1, module) {
-    module.exports = (value) => {
-      const type = typeof value;
-      return value !== null && (type === "object" || type === "function");
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/dot-prop@5.3.0/node_modules/dot-prop/index.js
-var require_dot_prop = __commonJS({
-  "../../node_modules/.pnpm/dot-prop@5.3.0/node_modules/dot-prop/index.js"(exports$1, module) {
-    var isObj = require_is_obj();
-    var disallowedKeys = [
-      "__proto__",
-      "prototype",
-      "constructor"
-    ];
-    var isValidPath = /* @__PURE__ */ __name((pathSegments) => !pathSegments.some((segment) => disallowedKeys.includes(segment)), "isValidPath");
-    function getPathSegments(path) {
-      const pathArray = path.split(".");
-      const parts = [];
-      for (let i = 0; i < pathArray.length; i++) {
-        let p = pathArray[i];
-        while (p[p.length - 1] === "\\" && pathArray[i + 1] !== void 0) {
-          p = p.slice(0, -1) + ".";
-          p += pathArray[++i];
-        }
-        parts.push(p);
-      }
-      if (!isValidPath(parts)) {
-        return [];
-      }
-      return parts;
-    }
-    __name(getPathSegments, "getPathSegments");
-    module.exports = {
-      get(object, path, value) {
-        if (!isObj(object) || typeof path !== "string") {
-          return value === void 0 ? object : value;
-        }
-        const pathArray = getPathSegments(path);
-        if (pathArray.length === 0) {
-          return;
-        }
-        for (let i = 0; i < pathArray.length; i++) {
-          if (!Object.prototype.propertyIsEnumerable.call(object, pathArray[i])) {
-            return value;
-          }
-          object = object[pathArray[i]];
-          if (object === void 0 || object === null) {
-            if (i !== pathArray.length - 1) {
-              return value;
-            }
-            break;
-          }
-        }
-        return object;
-      },
-      set(object, path, value) {
-        if (!isObj(object) || typeof path !== "string") {
-          return object;
-        }
-        const root = object;
-        const pathArray = getPathSegments(path);
-        for (let i = 0; i < pathArray.length; i++) {
-          const p = pathArray[i];
-          if (!isObj(object[p])) {
-            object[p] = {};
-          }
-          if (i === pathArray.length - 1) {
-            object[p] = value;
-          }
-          object = object[p];
-        }
-        return root;
-      },
-      delete(object, path) {
-        if (!isObj(object) || typeof path !== "string") {
-          return false;
-        }
-        const pathArray = getPathSegments(path);
-        for (let i = 0; i < pathArray.length; i++) {
-          const p = pathArray[i];
-          if (i === pathArray.length - 1) {
-            delete object[p];
-            return true;
-          }
-          object = object[p];
-          if (!isObj(object)) {
-            return false;
-          }
-        }
-      },
-      has(object, path) {
-        if (!isObj(object) || typeof path !== "string") {
-          return false;
-        }
-        const pathArray = getPathSegments(path);
-        if (pathArray.length === 0) {
-          return false;
-        }
-        for (let i = 0; i < pathArray.length; i++) {
-          if (isObj(object)) {
-            if (!(pathArray[i] in object)) {
-              return false;
-            }
-            object = object[pathArray[i]];
-          } else {
-            return false;
-          }
-        }
-        return true;
-      }
-    };
-  }
-});
-
-// ../../node_modules/.pnpm/to-fast-properties@3.0.1/node_modules/to-fast-properties/index.js
-var require_to_fast_properties = __commonJS({
-  "../../node_modules/.pnpm/to-fast-properties@3.0.1/node_modules/to-fast-properties/index.js"(exports$1, module) {
-    var fastProto = null;
-    function FastObject(o) {
-      if (fastProto !== null && typeof fastProto.property) {
-        const result = fastProto;
-        fastProto = FastObject.prototype = null;
-        return result;
-      }
-      fastProto = FastObject.prototype = o == null ? /* @__PURE__ */ Object.create(null) : o;
-      return new FastObject();
-    }
-    __name(FastObject, "FastObject");
-    var inlineCacheCutoff = 10;
-    for (let i = 0; i <= inlineCacheCutoff; i++) {
-      FastObject();
-    }
-    module.exports = /* @__PURE__ */ __name(function toFastproperties(o) {
-      return FastObject(o);
-    }, "toFastproperties");
-  }
-});
+import { __name } from './chunk-SHUYVCID.js';
+import dotProp from 'dot-prop';
+import toFastPropertiesOri from 'to-fast-properties';
 
 // ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/iterators.js
 var __\u03A9ArrayLike = [
@@ -295,9 +154,6 @@ eachPair.__type = [
   "eachPair",
   `PPP&"LM"o!"J2"PP&"GP'"GJo#"/$`
 ];
-
-// ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/core.js
-var import_dot_prop = __toESM(require_dot_prop(), 1);
 var __\u03A9Object = [
   () => Function,
   "constructor",
@@ -1016,7 +872,7 @@ function getPathValue(bag, parameterPath, defaultValue) {
   if (isSet(bag[parameterPath])) {
     return bag[parameterPath];
   }
-  const result = import_dot_prop.default.get(bag, parameterPath);
+  const result = dotProp.get(bag, parameterPath);
   return isSet(result) ? result : defaultValue;
 }
 __name(getPathValue, "getPathValue");
@@ -1028,7 +884,7 @@ getPathValue.__type = [
   'PP&"LM2!&2""2#8"/$'
 ];
 function setPathValue(bag, parameterPath, value) {
-  import_dot_prop.default.set(bag, parameterPath, value);
+  dotProp.set(bag, parameterPath, value);
 }
 __name(setPathValue, "setPathValue");
 setPathValue.__type = [
@@ -1039,7 +895,7 @@ setPathValue.__type = [
   'P%2!&2""2#"/$'
 ];
 function deletePathValue(bag, parameterPath) {
-  import_dot_prop.default.delete(bag, parameterPath);
+  dotProp.delete(bag, parameterPath);
 }
 __name(deletePathValue, "deletePathValue");
 deletePathValue.__type = [
@@ -1373,11 +1229,8 @@ assertDefined.__type = [
   "assertDefined",
   'P"2!!/"'
 ];
-
-// ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/perf.js
-var import_to_fast_properties = __toESM(require_to_fast_properties(), 1);
 function toFastProperties(obj) {
-  (0, import_to_fast_properties.default)(obj);
+  toFastPropertiesOri(obj);
 }
 __name(toFastProperties, "toFastProperties");
 toFastProperties.__type = [

package/dist/vendor/chunk-IOMA7ABE.js

@@ -0,0 +1,359 @@
+import { dirname, join, isAbsolute } from 'path';
+import ts2 from 'typescript';
+import { readFileSync } from 'fs';
+import micromatch from 'micromatch';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=88e8267ac73f46799c551ae3696181dc1f272895f490f8c_ef8b874d406bec4900e1fddc1ea375be/node_modules/@deepkit/type-compiler/dist/esm/src/debug.js
+function isDebug(level = 1) {
+  const expected = "deepkit" + (level > 1 ? "+".repeat(level - 1) : "");
+  return "undefined" !== typeof process && "string" === typeof process.env.DEBUG && process.env.DEBUG.includes(expected);
+}
+__name(isDebug, "isDebug");
+function debug(...message) {
+  if (isDebug(1)) {
+    console.debug(...message);
+  }
+}
+__name(debug, "debug");
+function debug2(...message) {
+  if (isDebug(2)) {
+    console.debug(...message);
+  }
+}
+__name(debug2, "debug2");
+var { createSourceFile, resolveModuleName, isStringLiteral, JSDocParsingMode, ScriptTarget } = ts2;
+function patternMatch(path, patterns, base) {
+  const include = patterns.filter((pattern) => pattern[0] !== "!");
+  const exclude = patterns.filter((pattern) => pattern[0] === "!").map((pattern) => pattern.substring(1));
+  return micromatch.isMatch(path, include, {
+    ignore: exclude
+  });
+}
+__name(patternMatch, "patternMatch");
+var Resolver = class {
+  static {
+    __name(this, "Resolver");
+  }
+  constructor(compilerOptions, host, sourceFiles) {
+    this.compilerOptions = compilerOptions;
+    this.host = host;
+    this.sourceFiles = sourceFiles;
+  }
+  resolve(from, importOrExportNode) {
+    const moduleSpecifier = importOrExportNode.moduleSpecifier;
+    if (!moduleSpecifier) return;
+    if (!isStringLiteral(moduleSpecifier)) return;
+    return this.resolveSourceFile(from, moduleSpecifier);
+  }
+  resolveImpl(modulePath, sourceFile) {
+    if (this.host.resolveModuleNameLiterals !== void 0) {
+      const results = this.host.resolveModuleNameLiterals(
+        [
+          modulePath
+        ],
+        sourceFile.fileName,
+        /*reusedNames*/
+        void 0,
+        this.compilerOptions,
+        sourceFile,
+        void 0
+      );
+      if (results[0]) return results[0].resolvedModule;
+      return;
+    }
+    if (this.host.resolveModuleNames !== void 0) {
+      return this.host.resolveModuleNames(
+        [
+          modulePath.text
+        ],
+        sourceFile.fileName,
+        /*reusedNames*/
+        void 0,
+        /*redirectedReference*/
+        void 0,
+        this.compilerOptions
+      )[0];
+    }
+    const result = resolveModuleName(modulePath.text, sourceFile.fileName, this.compilerOptions, this.host);
+    return result.resolvedModule;
+  }
+  /**
+   * Tries to resolve the .ts/d.ts file path for a given module path.
+   * Scans relative paths. Looks into package.json "types" and "exports" (with new 4.7 support)
+   *
+   * @param sourceFile the SourceFile of the file that contains the import. modulePath is relative to that.
+   * @param modulePath the x in 'from x'.
+   */
+  resolveSourceFile(sourceFile, modulePath) {
+    const result = this.resolveImpl(modulePath, sourceFile);
+    if (!result) return;
+    if (!result.resolvedFileName.endsWith(".ts") && !result.resolvedFileName.endsWith(".tsx") && !result.resolvedFileName.endsWith(".d.ts")) {
+      return;
+    }
+    const fileName = result.resolvedFileName;
+    if (this.sourceFiles[fileName]) return this.sourceFiles[fileName];
+    const source = this.host.readFile(result.resolvedFileName);
+    if (!source) return;
+    const moduleSourceFile = this.sourceFiles[fileName] = createSourceFile(fileName, source, {
+      languageVersion: this.compilerOptions.target || ScriptTarget.ES2018,
+      // JSDocParsingMode is not available in TS < 5.3
+      jsDocParsingMode: JSDocParsingMode ? JSDocParsingMode.ParseNone : void 0
+    }, true);
+    this.sourceFiles[fileName] = moduleSourceFile;
+    ts2.bindSourceFile(moduleSourceFile, this.compilerOptions);
+    return moduleSourceFile;
+  }
+};
+
+// ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=88e8267ac73f46799c551ae3696181dc1f272895f490f8c_ef8b874d406bec4900e1fddc1ea375be/node_modules/@deepkit/type-compiler/dist/esm/src/config.js
+var reflectionModes = [
+  "default",
+  "explicit",
+  "never"
+];
+function isObject(obj) {
+  if (!obj) {
+    return false;
+  }
+  return typeof obj === "object" && !Array.isArray(obj);
+}
+__name(isObject, "isObject");
+var defaultMergeStrategy = "merge";
+var reflectionLevel = [
+  "minimal",
+  "normal",
+  "verbose"
+];
+function readTsConfig(parseConfigHost, path) {
+  const configFile = ts2.readConfigFile(path, (path2) => parseConfigHost.readFile(path2));
+  if (configFile.error) {
+    debug(`Failed to read tsconfig ${path}: ${configFile.error.messageText}`);
+    return;
+  }
+  const parsed = ts2.parseJsonConfigFileContent(configFile.config, parseConfigHost, dirname(path));
+  const ignoredErrors = [
+    18003
+    // No inputs were found in config file.
+  ];
+  const softErrors = [
+    18e3
+    // Circularity detected while resolving configuration
+  ];
+  const errors = parsed.errors.filter((v) => !ignoredErrors.includes(v.code));
+  if (errors.length) {
+    debug(`Failed to parse tsconfig ${path}: ${parsed.errors.map((v) => v.messageText).join(", ")}`);
+  }
+  const hardErrors = errors.filter((v) => !softErrors.includes(v.code));
+  if (hardErrors.length) {
+    return;
+  }
+  const json = readFileSync(path, "utf8");
+  const tsconfig = JSON.parse(json);
+  return Object.assign(configFile.config, {
+    compilerOptions: parsed.options,
+    reflectionLevel: tsconfig.reflectionLevel ? String(tsconfig.reflectionLevel) : void 0
+  });
+}
+__name(readTsConfig, "readTsConfig");
+function reflectionModeMatcher(config, filePath) {
+  if (Array.isArray(config.exclude)) {
+    if (patternMatch(filePath, config.exclude)) return "never";
+  }
+  if (Array.isArray(config.reflection)) {
+    return patternMatch(filePath, config.reflection) ? "default" : "never";
+  }
+  if (config.reflection === "default" || config.reflection === "explicit") return config.reflection;
+  return "never";
+}
+__name(reflectionModeMatcher, "reflectionModeMatcher");
+function ensureStringArray(value) {
+  if (Array.isArray(value)) return value.map((v) => "" + v);
+  if ("string" === typeof value) return [
+    value
+  ];
+  return [];
+}
+__name(ensureStringArray, "ensureStringArray");
+function parseRawMode(mode) {
+  if ("boolean" === typeof mode) return mode ? "default" : "never";
+  if (mode === "default" || mode === "explicit") return mode;
+  return ensureStringArray(mode);
+}
+__name(parseRawMode, "parseRawMode");
+function resolvePaths(baseDir, paths) {
+  if (!paths || !Array.isArray(paths)) return;
+  for (let i = 0; i < paths.length; i++) {
+    if ("string" !== typeof paths[i]) continue;
+    if (isAbsolute(paths[i])) continue;
+    let path = paths[i];
+    let exclude = false;
+    if (path.startsWith("!")) {
+      exclude = true;
+      path = path.substring(1);
+    }
+    if (path.startsWith("./") || path.includes("/")) {
+      path = join(baseDir, path);
+    }
+    path = path.replace(/\\/g, "/");
+    if (exclude) path = "!" + path;
+    paths[i] = path;
+  }
+}
+__name(resolvePaths, "resolvePaths");
+function appendPaths(strategy = defaultMergeStrategy, parent, existing) {
+  if (strategy === "replace") {
+    return [
+      ...existing || parent
+    ];
+  }
+  if (!existing) return [
+    ...parent
+  ];
+  return [
+    ...parent,
+    ...existing
+  ];
+}
+__name(appendPaths, "appendPaths");
+function applyConfigValues(existing, parent, baseDir) {
+  const parentReflection = isObject(parent.deepkitCompilerOptions) ? parent.deepkitCompilerOptions?.reflection : parent.reflection;
+  const parentReflectionLevel = parent.deepkitCompilerOptions?.reflectionLevel || parent.reflectionLevel || parent.compilerOptions?.reflectionLevel;
+  if (isObject(parent.deepkitCompilerOptions) && "undefined" === typeof existing.mergeStrategy) {
+    existing.mergeStrategy = parent.deepkitCompilerOptions.mergeStrategy;
+  }
+  if ("undefined" !== typeof parentReflection) {
+    const next = parseRawMode(parentReflection);
+    if ("undefined" === typeof existing.reflection) {
+      existing.reflection = next;
+    } else if ("string" === typeof existing.reflection) ; else if (Array.isArray(next) && Array.isArray(existing.reflection)) {
+      existing.reflection = appendPaths(existing.mergeStrategy, next, existing.reflection);
+    } else if ("string" === typeof next && Array.isArray(existing.reflection)) ;
+  }
+  if ("undefined" !== typeof parentReflectionLevel) {
+    if ("undefined" === typeof existing.reflectionLevel) {
+      existing.reflectionLevel = parentReflectionLevel;
+    }
+  }
+  if (isObject(parent.deepkitCompilerOptions)) {
+    if (`undefined` !== typeof parent.deepkitCompilerOptions.exclude) {
+      const next = ensureStringArray(parent.deepkitCompilerOptions.exclude);
+      existing.exclude = appendPaths(existing.mergeStrategy, next, existing.exclude);
+    }
+  }
+  resolvePaths(baseDir, existing.reflection);
+  resolvePaths(baseDir, existing.exclude);
+  if (parent.compilerOptions) {
+    if (Object.keys(existing.compilerOptions).length === 0) {
+      Object.assign(existing.compilerOptions, parent.compilerOptions);
+    }
+  }
+  existing.extends = parent.extends;
+}
+__name(applyConfigValues, "applyConfigValues");
+var defaultExcluded = [
+  "lib.dom*.d.ts",
+  "*typedarrays.d.ts",
+  "lib.webworker*.d.ts",
+  "lib.decorator*.d.ts",
+  "lib.es2015.proxy.d.ts",
+  "lib.es2020.sharedmemory.d.ts",
+  "lib.es2015.core.d.ts"
+];
+function getConfigResolver(cache, host, compilerOptions, sourceFile, tsConfigPath = "") {
+  let config = {
+    // We use the parameter `compilerOptions` only for compilerOptions.configFilePath.
+    // We load the compilerOptions manually since transformers don't get the full picture
+    // (path aliases are missing for example).
+    // It's important to load compilerOptions manually if there is compilerOptions.configFilePath
+    // since not all build tools provide the full compilerOptions.
+    compilerOptions: {}
+  };
+  tsConfigPath = tsConfigPath || ("string" === typeof compilerOptions.configFilePath ? compilerOptions.configFilePath : "");
+  if (tsConfigPath) {
+    if (cache[tsConfigPath]) {
+      return cache[tsConfigPath];
+    }
+    const configFile = readTsConfig(host, tsConfigPath);
+    if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+  } else {
+    if (!tsConfigPath && sourceFile) {
+      const baseDir = dirname(sourceFile.fileName);
+      const configPath = ts2.findConfigFile(baseDir, (path) => {
+        path = isAbsolute(path) ? path : join(baseDir, path);
+        return host.fileExists(path);
+      });
+      debug2(`No tsConfigPath|compilerOptions.configFilePath provided. Manually searching for tsconfig.json in ${baseDir} returned ${configPath}`);
+      if (configPath) {
+        tsConfigPath = isAbsolute(configPath) ? configPath : join(baseDir, configPath);
+      }
+    }
+    if (tsConfigPath) {
+      if (cache[tsConfigPath]) return cache[tsConfigPath];
+      const configFile = readTsConfig(host, tsConfigPath);
+      if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+    }
+  }
+  if (tsConfigPath) {
+    let basePath = dirname(tsConfigPath);
+    let currentConfig = config;
+    const seen = /* @__PURE__ */ new Set();
+    seen.add(tsConfigPath);
+    while (currentConfig.extends) {
+      const path = join(basePath, currentConfig.extends);
+      if (seen.has(path)) break;
+      seen.add(path);
+      const nextConfig = ts2.readConfigFile(path, (path2) => host.readFile(path2));
+      if (!nextConfig) break;
+      basePath = dirname(path);
+      applyConfigValues(currentConfig, nextConfig.config, basePath);
+    }
+  } else {
+    throw new Error(`No tsconfig found for ${sourceFile?.fileName}, that is weird. Either provide a tsconfig or compilerOptions.configFilePath`);
+  }
+  config.exclude = config.exclude ? [
+    ...defaultExcluded,
+    ...config.exclude
+  ] : [
+    ...defaultExcluded
+  ];
+  config.compilerOptions.configFilePath = tsConfigPath;
+  const resolvedConfig = {
+    path: tsConfigPath,
+    // we want to maintain options passed from tsc API (transpile, Program)
+    compilerOptions: Object.assign(config.compilerOptions, compilerOptions),
+    exclude: config.exclude,
+    reflection: config.reflection,
+    reflectionLevel: config.reflectionLevel || (config.compilerOptions?.reflectionLevel ? String(config.compilerOptions?.reflectionLevel) : void 0) || "normal",
+    mergeStrategy: config.mergeStrategy || defaultMergeStrategy
+  };
+  if (isDebug()) {
+    debug(`Found config ${resolvedConfig.path}:
+reflection:`, resolvedConfig.reflection, `
+exclude:`, resolvedConfig.exclude, `
+paths:`, resolvedConfig.compilerOptions.paths);
+  }
+  const match = /* @__PURE__ */ __name((path) => {
+    const mode = reflectionModeMatcher(config, path);
+    return {
+      mode,
+      tsConfigPath,
+      level: resolvedConfig.reflectionLevel
+    };
+  }, "match");
+  return cache[tsConfigPath] = {
+    config: resolvedConfig,
+    match
+  };
+}
+__name(getConfigResolver, "getConfigResolver");
+
+export { Resolver, __name, __require, debug, debug2, defaultExcluded, getConfigResolver, isObject, parseRawMode, reflectionLevel, reflectionModeMatcher, reflectionModes };