typia 13.3.0 → 14.0.0

package/native/core/programmers/iterate/check_dynamic_properties.go

@@ -1,11 +1,14 @@
 package iterate
 
 import (
+  "strings"
+
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
   nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
   nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
   nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 type Check_dynamic_propertiesProps struct {
@@ -126,7 +129,11 @@ func check_dynamic_property(props Check_dynamic_propertiesProps) *shimast.Node {
       nil,
     ))
   }
-  broken := false
+  // terminated marks that `statements` already ends in an unconditional return,
+  // so nothing after it could run. A signature that accepts every key sets it
+  // from the loop; a declared key type that covers every key sets it from the
+  // tail below.
+  terminated := false
 
   if len(props.Regular) != 0 {
     add(is_regular_property(props.Regular, props.Context.Emit), props.Config.Positive)
@@ -156,13 +163,58 @@ func check_dynamic_property(props Check_dynamic_propertiesProps) *shimast.Node {
     })
     if condition.Kind == shimast.KindTrueKeyword {
       statements = append(statements, f.NewReturnStatement(entry.Expression))
-      broken = true
+      terminated = true
       break
     }
     add(condition, entry.Expression)
   }
 
-  if !broken {
+  if !terminated {
+    // Reaching here means the key satisfied no dynamic signature. Two different
+    // things bring a key here, and they are not the same failure.
+    //
+    // A key whose *declared type* no signature covers -- `wrong` against
+    // `[key: `prefix_${string}`]` -- is an extra property. Nothing declares it,
+    // so `is` accepts it as it accepts any surplus property, and `equals`
+    // reports it through `Superfluous`.
+    //
+    // A key the declaration does cover but whose *type tag* it breaks -- `ab`
+    // against `[key: string & tags.MinLength<3>]` -- is a declared property
+    // with an invalid key. It used to reach the same accepting tail, which made
+    // every key tag inert: `[key: string & tags.Format<"uuid">]` accepted any
+    // key at all, while the emitted check sat right above, used only to decide
+    // *which* signature's value type to apply (#2347).
+    //
+    // So the tag failure is separated out first, by re-asking the same key
+    // question with every type tag removed. What is left is exactly the
+    // declared key type, and a key that answers it is a member of the object
+    // whose key broke a constraint -- never a surplus property.
+    shape := check_dynamic_properties_key_shape(props, key)
+    if shape != nil {
+      var invalid *shimast.Node
+      if props.Config.InvalidKey != nil {
+        invalid = props.Config.InvalidKey(
+          value,
+          check_dynamic_properties_key_expected(props.Dynamic),
+          check_dynamic_properties_invalid_key_description(props.Context.Emit),
+        )
+      } else {
+        // A programmer with no better report reduces both to the same answer,
+        // as `is` does with `false`.
+        invalid = props.Config.Superfluous(value, check_dynamic_properties_superfluous_description(props.Context.Emit))
+      }
+      if shape.Kind == shimast.KindTrueKeyword {
+        // Every key the signature accepts is covered -- a string index
+        // signature covers every key `Object.keys` can yield -- so the surplus
+        // tail below is unreachable and is not emitted.
+        statements = append(statements, f.NewReturnStatement(invalid))
+        terminated = true
+      } else {
+        add(shape, invalid)
+      }
+    }
+  }
+  if !terminated {
     output := props.Config.Positive
     if props.Config.Equals {
       output = props.Config.Superfluous(value, check_dynamic_properties_superfluous_description(props.Context.Emit))
@@ -257,6 +309,128 @@ func check_dynamic_properties_internal(context nativecontext.ITypiaContext, name
   return f.NewIdentifier(name)
 }
 
+// The condition that the key belongs to some index signature's declared key
+// type while breaking that signature's type tags -- the question the tail has
+// to answer to tell an invalid key from a surplus property.
+//
+// It is the same `Check_dynamic_key` question asked of every signature with its
+// type tags removed, joined with `||`. The tail runs only after each full
+// condition returned false, so a signature whose declared type still answers
+// yes is one whose tags are what the key broke.
+//
+// Nil when no signature carries a key tag. Then each stripped condition equals
+// the full one the tail already refuted, so the check could never fire, and an
+// object with untagged index signatures emits exactly what it emitted before.
+func check_dynamic_properties_key_shape(props Check_dynamic_propertiesProps, key *shimast.Expression) *shimast.Node {
+  tagged := false
+  for _, entry := range props.Dynamic {
+    if check_dynamic_properties_key_tagged(entry.Key) {
+      tagged = true
+      break
+    }
+  }
+  if !tagged {
+    return nil
+  }
+  conditions := make([]*shimast.Node, 0, len(props.Dynamic))
+  for _, entry := range props.Dynamic {
+    condition := Check_dynamic_key(Check_dynamic_keyProps{
+      Context:  props.Context,
+      Metadata: check_dynamic_properties_key_untagged(entry.Key),
+      Input:    key,
+    })
+    if condition.Kind == shimast.KindTrueKeyword {
+      return condition
+    }
+    conditions = append(conditions, condition)
+  }
+  return check_dynamic_key_reduce(conditions, shimast.KindBarBarToken, props.Context.Emit)
+}
+
+// Whether the key declaration constrains more than its own type, which is what
+// makes the stripped question differ from the full one.
+//
+// One tag carrying a runtime check is enough, and the row it sits in need not
+// carry them all. `Check_string` and `Check_number` filter per tag, so
+// `[key: number & Minimum<0> & <a tag with no runtime check>]` still emits the
+// minimum -- reading the row as all-or-nothing here would have declared that
+// key untagged and left its minimum inert, which is the defect #2347 closed.
+//
+// Answering yes where the stripped question turns out identical costs an
+// unreachable branch, never a wrong answer: the tail is reached only after
+// every full condition refused the key, so a stripped condition equal to one of
+// them refuses it too.
+func check_dynamic_properties_key_tagged(metadata *nativemetadata.MetadataSchema) bool {
+  for _, atomic := range metadata.Atomics {
+    for _, row := range atomic.Tags {
+      for _, tag := range row {
+        if tag.Validate != "" {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
+
+// The key declaration with its type tags removed, leaving the declared type
+// alone. Templates, constants, and natives carry no tags, so only the atomics
+// are rebuilt; the clone keeps the original reportable name untouched.
+func check_dynamic_properties_key_untagged(metadata *nativemetadata.MetadataSchema) *nativemetadata.MetadataSchema {
+  clone := *metadata
+  clone.Atomics = make([]*nativemetadata.MetadataAtomic, 0, len(metadata.Atomics))
+  for _, atomic := range metadata.Atomics {
+    clone.Atomics = append(clone.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{
+      Type: atomic.Type,
+    }))
+  }
+  return &clone
+}
+
+// The type every declared key would have satisfied, for the report. Several
+// signatures join with `|`, which is how the declaration reads.
+func check_dynamic_properties_key_expected(dynamic []nativehelpers.IExpressionEntry) string {
+  names := make([]string, 0, len(dynamic))
+  for _, entry := range dynamic {
+    names = append(names, entry.Key.GetName())
+  }
+  return strings.Join(names, " | ")
+}
+
+// The advice `Superfluous` gives -- remove the property -- is wrong here. The
+// property is declared; its key is what broke.
+func check_dynamic_properties_invalid_key_description(emit ...*shimprinter.EmitContext) *shimast.Node {
+  f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, emit...)
+  return f.NewCallExpression(
+    nativefactories.IdentifierFactory.Access(
+      nil,
+      f.NewArrayLiteralExpression(
+        f.NewNodeList([]*shimast.Node{
+          f.NewTemplateExpression(
+            f.NewTemplateHead("The key `", "The key \\`", shimast.TokenFlagsNone),
+            f.NewNodeList([]*shimast.Node{
+              f.NewTemplateSpan(
+                f.NewIdentifier("key"),
+                f.NewTemplateTail("` does not satisfy the type its index signature declares.", "\\` does not satisfy the type its index signature declares.", shimast.TokenFlagsNone),
+              ),
+            }),
+          ),
+          f.NewStringLiteral("", shimast.TokenFlagsNone),
+          f.NewStringLiteral("Please correct the key next time.", shimast.TokenFlagsNone),
+        }),
+        true,
+      ),
+      "join",
+    ),
+    nil,
+    nil,
+    f.NewNodeList([]*shimast.Node{
+      f.NewStringLiteral("\n", shimast.TokenFlagsNone),
+    }),
+    shimast.NodeFlagsNone,
+  )
+}
+
 func check_dynamic_properties_superfluous_description(emit ...*shimprinter.EmitContext) *shimast.Node {
   f := nativecontext.EmitFactoryOf(check_dynamic_properties_factory, emit...)
   return f.NewCallExpression(

package/native/core/programmers/iterate/check_object.go

@@ -22,7 +22,18 @@ type Check_object_IConfig struct {
   Reduce      func(a *shimast.Expression, b *shimast.Expression) *shimast.Node
   Positive    *shimast.Expression
   Superfluous func(value *shimast.Expression, description *shimast.Expression) *shimast.Node
-  Entries     *shimast.Expression
+  // InvalidKey reports a dynamic key an index signature declares but whose type
+  // tag it breaks. A key no signature declares at all is a surplus property and
+  // goes to `Superfluous` instead.
+  //
+  // `Superfluous` is the wrong report for this one: it says the property is not
+  // defined in the object type and advises removing it, which is false and
+  // unhelpful when the property *is* declared and only its key broke a
+  // constraint. A programmer that has no better answer may leave this nil, and
+  // `Superfluous` is used instead -- the outcome is identical, only the message
+  // differs.
+  InvalidKey func(value *shimast.Expression, expected string, description *shimast.Expression) *shimast.Node
+  Entries    *shimast.Expression
 }
 
 func Check_object(props Check_objectProps) *shimast.Node {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "13.3.0",
+  "version": "14.0.0",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -26,9 +26,6 @@
     },
     "./package.json": "./package.json"
   },
-  "bin": {
-    "typia": "./lib/executable/typia.js"
-  },
   "ttsc": {
     "plugin": {
       "transform": "typia/lib/transform"
@@ -46,12 +43,9 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "@standard-schema/spec": "^1.0.0",
-    "commander": "^10.0.0",
-    "inquirer": "^8.2.5",
     "randexp": "^0.5.3",
-    "tinyglobby": "^0.2.12",
-    "@typia/interface": "^13.3.0",
-    "@typia/utils": "^13.3.0"
+    "@typia/interface": "^14.0.0",
+    "@typia/utils": "^14.0.0"
   },
   "peerDependencies": {
     "ttsc": ">=0.19.2"
@@ -62,12 +56,9 @@
     }
   },
   "devDependencies": {
-    "@types/inquirer": "^8.2.5",
     "@types/node": "^25.3.0",
-    "chalk": "^4.0.0",
     "rimraf": "^6.1.2",
     "rolldown": "^1.1.5",
-    "suppress-warnings": "^1.0.2",
     "ttsc": "^0.19.2",
     "typescript": "^7.0.2"
   },

package/src/internal/_randomPattern.ts

@@ -1,6 +1,7 @@
 import RandExp from "randexp";
 
 import { _ILengthProps } from "./_randomStringLength";
+import { _stringLength } from "./_stringLength";
 
 export const _randomPattern = (
   regex: RegExp,
@@ -16,14 +17,28 @@ export const _randomPattern = (
   if (max !== undefined) r.max = max;
   else if (min !== undefined && min * 2 > r.max) r.max = min * 2;
 
+  // The verification counts characters, not UTF-16 code units, because that is
+  // what `MinLength` and `MaxLength` compare against. `Pattern` compiles to a
+  // flagless `RegExp`, so a quantifier binds one code unit wherever its atom is
+  // a bare astral character: under `^😀+$` the `+` repeats the trailing low
+  // surrogate alone, and RandExp draws `\ud83d` + k * `\ude00` -- k characters
+  // in k + 1 code units. Measuring in code units accepted a two-character draw
+  // for `MinLength<3>` and handed back a value the generated validator rejects.
+  // Group the atom (`^(?:😀)+$`) and the arithmetic changes to 2k units for k
+  // characters; the two counts still differ, which is the point.
+  //
+  // The count is taken only after the pattern matches, and only when a bound
+  // exists, so an unbounded draw still walks nothing.
   const bounded: boolean = min !== undefined || max !== undefined;
   const limit: number = bounded ? 1024 : 10;
   for (let i: number = 0; i < limit; ++i) {
     const str: string = r.gen();
+    if (regex.test(str) === false) continue;
+    if (bounded === false) return str;
+    const length: number = _stringLength(str);
     if (
-      regex.test(str) &&
-      (min === undefined || str.length >= min) &&
-      (max === undefined || str.length <= max)
+      (min === undefined || length >= min) &&
+      (max === undefined || length <= max)
     )
       return str;
   }

package/src/internal/_randomStringLength.ts

@@ -1,5 +1,6 @@
 import { _randomInteger } from "./_randomInteger";
 import { _randomString } from "./_randomString";
+import { _stringLength } from "./_stringLength";
 
 export const _RANDOM_LENGTH_ERROR =
   "unable to generate a random string satisfying both the format and the length constraints.";
@@ -106,9 +107,15 @@ export const _randomFormatLength = (
     return generate();
   for (let i: number = 0; i < 256; ++i) {
     const value: string = generate();
+    // Characters, not UTF-16 code units: `minLength` and `maxLength` are the
+    // bounds the generated validator compares in characters. `uuid` and `date`,
+    // the only two shapes routed through here, are ASCII, so the two counts
+    // agree for them today -- this keeps one measure so a later non-ASCII
+    // format cannot reintroduce the divergence unnoticed.
+    const length: number = _stringLength(value);
     if (
-      (props.minLength === undefined || value.length >= props.minLength) &&
-      (props.maxLength === undefined || value.length <= props.maxLength)
+      (props.minLength === undefined || length >= props.minLength) &&
+      (props.maxLength === undefined || length <= props.maxLength)
     )
       return value;
   }

package/lib/executable/FileSystemIdentity.d.ts

@@ -1,44 +0,0 @@
-import fs from "fs";
-import path from "path";
-export declare namespace FileSystemIdentity {
-    interface IIdentity {
-        readonly caseSensitive: boolean;
-        contains(file: string, directory: string): boolean;
-        filesystemKey(file: string): string;
-        isDeclarationFile(file: string): boolean;
-        isSamePath(x: string, y: string): boolean;
-        isSupportedExtension(file: string): boolean;
-        projectFileKey(file: string): string;
-    }
-    function create(caseSensitive: boolean, pathApi?: typeof path.posix): IIdentity;
-    class Policy {
-        private caseSensitive_;
-        private location_;
-        observe(caseSensitive: boolean | undefined, location: string): void;
-        get(): IIdentity;
-    }
-    function inspectDirectory(directory: string): Promise<boolean | undefined>;
-    function probeDirectory(directory: string): Promise<boolean>;
-    /**
-     * Builds the key that decides whether two paths are the same filesystem
-     * object.
-     *
-     * The identity is read from `fs.BigIntStats` rather than `fs.Stats`, because
-     * `fs.Stats.ino` is a JavaScript number. An NTFS file ID is `(sequenceNumber
-     * << 48) | mftRecordIndex` and routinely exceeds `Number.MAX_SAFE_INTEGER` —
-     * in a 4000-directory probe, 1879 of them did — where the spacing between
-     * representable doubles is 8 or more. Two entries sharing a sequence number
-     * with MFT record indices within that spacing round to one double. The
-     * traversal callers would then treat a distinct directory or file as already
-     * visited and skip it with no diagnostic, and the overwrite guard would
-     * refuse a legitimate output (samchon/typia#2269).
-     *
-     * A filesystem that reports no inode at all keeps the canonical path
-     * fallback, which is the only identity available there.
-     *
-     * @param stat Stats read with `{ bigint: true }`.
-     * @param realpath Canonical path of the same object.
-     * @returns Key that is equal for two paths only when they are one object.
-     */
-    function identityKey(stat: Pick<fs.BigIntStats, "dev" | "ino">, realpath: string): string;
-}

package/lib/executable/FileSystemIdentity.js

@@ -1,213 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemIdentity = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-var FileSystemIdentity;
-(function (FileSystemIdentity) {
-    function create(caseSensitive, pathApi = path_1.default) {
-        const fold = (value) => caseSensitive ? value : value.toLowerCase();
-        const filesystemKey = (file) => fold(pathApi.normalize(file));
-        return {
-            caseSensitive,
-            contains: (file, directory) => {
-                const fileKey = filesystemKey(pathApi.resolve(file));
-                const directoryKey = filesystemKey(pathApi.resolve(directory));
-                const prefix = directoryKey.endsWith(pathApi.sep)
-                    ? directoryKey
-                    : `${directoryKey}${pathApi.sep}`;
-                return fileKey === directoryKey || fileKey.startsWith(prefix);
-            },
-            filesystemKey,
-            isDeclarationFile: (file) => DTS_PATTERN.test(fold(pathApi.basename(file))),
-            isSamePath: (x, y) => filesystemKey(x) === filesystemKey(y),
-            isSupportedExtension: (file) => {
-                const filename = fold(pathApi.basename(file));
-                return (TS_PATTERN.test(filename) && DTS_PATTERN.test(filename) === false);
-            },
-            projectFileKey: fold,
-        };
-    }
-    FileSystemIdentity.create = create;
-    class Policy {
-        observe(caseSensitive, location) {
-            if (caseSensitive === undefined)
-                return;
-            if (this.caseSensitive_ === undefined) {
-                this.caseSensitive_ = caseSensitive;
-                this.location_ = location;
-            }
-            else if (this.caseSensitive_ !== caseSensitive) {
-                throw new URIError(`Error on TypiaGenerateWizard.generate(): inconsistent filesystem case behavior between ${this.location_} and ${location}.`);
-            }
-        }
-        get() {
-            if (this.caseSensitive_ === undefined) {
-                throw new URIError("Error on TypiaGenerateWizard.generate(): unable to determine filesystem case behavior for this run.");
-            }
-            return create(this.caseSensitive_);
-        }
-    }
-    FileSystemIdentity.Policy = Policy;
-    function inspectDirectory(directory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const names = yield fs_1.default.promises.readdir(directory);
-            const entries = new Set(names);
-            for (const name of names) {
-                const alternate = alternateCase(name);
-                if (alternate === undefined)
-                    continue;
-                if (entries.has(alternate))
-                    return true;
-                try {
-                    yield fs_1.default.promises.lstat(path_1.default.join(directory, alternate));
-                    return false;
-                }
-                catch (error) {
-                    if (isMissingFileError(error))
-                        return true;
-                    throw error;
-                }
-            }
-            return undefined;
-        });
-    }
-    FileSystemIdentity.inspectDirectory = inspectDirectory;
-    function probeDirectory(directory) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const inspected = yield inspectDirectory(directory);
-            if (inspected !== undefined)
-                return inspected;
-            for (let attempt = 0; attempt < 10; ++attempt) {
-                const name = `.typia-case-probe-${process.pid}-${Date.now()}-${Math.random()
-                    .toString(36)
-                    .slice(2)}`.toLowerCase();
-                const original = path_1.default.join(directory, name);
-                const alternate = path_1.default.join(directory, name.toUpperCase());
-                let handle;
-                try {
-                    handle = yield fs_1.default.promises.open(original, "wx");
-                }
-                catch (error) {
-                    if (isAlreadyExistsError(error))
-                        continue;
-                    throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to probe filesystem case behavior at ${directory}: ${formatUnknownError(error)}`);
-                }
-                let closed = false;
-                try {
-                    yield handle.close();
-                    closed = true;
-                    try {
-                        yield fs_1.default.promises.lstat(alternate);
-                        return false;
-                    }
-                    catch (error) {
-                        if (isMissingFileError(error))
-                            return true;
-                        throw error;
-                    }
-                }
-                finally {
-                    let cleanupError;
-                    if (closed === false) {
-                        try {
-                            yield handle.close();
-                        }
-                        catch (error) {
-                            cleanupError = error;
-                        }
-                    }
-                    try {
-                        yield fs_1.default.promises.unlink(original);
-                    }
-                    catch (error) {
-                        if (isMissingFileError(error) === false)
-                            cleanupError !== null && cleanupError !== void 0 ? cleanupError : (cleanupError = error);
-                    }
-                    if (cleanupError !== undefined) {
-                        throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to clean filesystem case probe ${original}: ${formatUnknownError(cleanupError)}`);
-                    }
-                }
-            }
-            throw new URIError(`Error on TypiaGenerateWizard.generate(): unable to reserve a filesystem case probe at ${directory}.`);
-        });
-    }
-    FileSystemIdentity.probeDirectory = probeDirectory;
-    /**
-     * Builds the key that decides whether two paths are the same filesystem
-     * object.
-     *
-     * The identity is read from `fs.BigIntStats` rather than `fs.Stats`, because
-     * `fs.Stats.ino` is a JavaScript number. An NTFS file ID is `(sequenceNumber
-     * << 48) | mftRecordIndex` and routinely exceeds `Number.MAX_SAFE_INTEGER` —
-     * in a 4000-directory probe, 1879 of them did — where the spacing between
-     * representable doubles is 8 or more. Two entries sharing a sequence number
-     * with MFT record indices within that spacing round to one double. The
-     * traversal callers would then treat a distinct directory or file as already
-     * visited and skip it with no diagnostic, and the overwrite guard would
-     * refuse a legitimate output (samchon/typia#2269).
-     *
-     * A filesystem that reports no inode at all keeps the canonical path
-     * fallback, which is the only identity available there.
-     *
-     * @param stat Stats read with `{ bigint: true }`.
-     * @param realpath Canonical path of the same object.
-     * @returns Key that is equal for two paths only when they are one object.
-     */
-    function identityKey(stat, realpath) {
-        // `BigInt(0)` rather than `0n`: this package compiles at ES2016, where a
-        // BigInt literal is a syntax error, while the constructor and the `bigint`
-        // type are fine.
-        return stat.ino === BigInt(0)
-            ? `path:${path_1.default.normalize(realpath)}`
-            : `inode:${stat.dev}:${stat.ino}`;
-    }
-    FileSystemIdentity.identityKey = identityKey;
-    function alternateCase(name) {
-        let changed = false;
-        let output = "";
-        for (const character of name) {
-            if (character >= "a" && character <= "z") {
-                output += character.toUpperCase();
-                changed = true;
-            }
-            else if (character >= "A" && character <= "Z") {
-                output += character.toLowerCase();
-                changed = true;
-            }
-            else
-                output += character;
-        }
-        return changed ? output : undefined;
-    }
-    function isAlreadyExistsError(error) {
-        return (typeof error === "object" &&
-            error !== null &&
-            "code" in error &&
-            error.code === "EEXIST");
-    }
-    function isMissingFileError(error) {
-        return (typeof error === "object" &&
-            error !== null &&
-            "code" in error &&
-            error.code === "ENOENT");
-    }
-    function formatUnknownError(error) {
-        return error instanceof Error ? error.message : String(error);
-    }
-})(FileSystemIdentity || (exports.FileSystemIdentity = FileSystemIdentity = {}));
-const TS_PATTERN = /\.[cm]?tsx?$/;
-const DTS_PATTERN = /\.d\.[cm]?tsx?$/;
-//# sourceMappingURL=FileSystemIdentity.js.map

package/lib/executable/FileSystemIdentity.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FileSystemIdentity.js","sourceRoot":"","sources":["../../src/executable/FileSystemIdentity.ts"],"names":[],"mappings":"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"}