@endo/compartment-mapper 1.6.3 → 2.1.0

package/src/parse-cjs-shared-export-wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-cjs-shared-export-wrapper.d.ts","sourceRoot":"","sources":["parse-cjs-shared-export-wrapper.js"],"names":[],"mappings":"AA0CO,2CAPI,UAAU,GAAG,MAAM,GAAG,SAAS,YAC/B,MAAM,GACJ;IACR,QAAQ,EAAC,MAAM,GAAC,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,GAAC,IAAI,CAAA;CACrB,CAgCH;AAmBM,uGAZJ;IAAmB,uBAAuB,EAAlC,MAAM;IACU,WAAW,EAA3B,WAAW;IACgB,eAAe,EAA1C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IACX,QAAQ,EAAnB,MAAM;IAC8B,UAAU,EAA9C,MAAM,GAAG,UAAU,GAAG,SAAS;CACvC,GAAU;IACR,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,WAAW;IACvB,OAAO,WAAW;CACnB,CA+IH;gCAhOqC,YAAY;4BAAZ,YAAY"}
+{"version":3,"file":"parse-cjs-shared-export-wrapper.d.ts","sourceRoot":"","sources":["parse-cjs-shared-export-wrapper.js"],"names":[],"mappings":"AA0CO,2CAPI,UAAU,GAAG,MAAM,GAAG,SAAS,YAC/B,MAAM,GACJ;IACR,QAAQ,EAAC,MAAM,GAAC,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,GAAC,IAAI,CAAA;CACrB,CAgCH;AAmBM,uGAZJ;IAAmB,uBAAuB,EAAlC,MAAM;IACU,WAAW,EAA3B,WAAW;IACgB,eAAe,EAA1C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IACX,QAAQ,EAAnB,MAAM;IAC8B,UAAU,EAA9C,MAAM,GAAG,UAAU,GAAG,SAAS;CACvC,GAAU;IACR,MAAM,EAAE;QAAE,OAAO,EAAE,GAAG,CAAA;KAAE,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,WAAW;IACvB,OAAO,WAAW;CACnB,CAiJH;gCAlOqC,YAAY;4BAAZ,YAAY"}

package/src/parse-cjs-shared-export-wrapper.js

@@ -219,7 +219,9 @@ export const wrap = ({
       }
     } else {
       for (const prop of redefined) {
-        moduleEnvironmentRecord[prop] = moduleEnvironmentRecord.default[prop];
+        if (prop !== 'default') {
+          moduleEnvironmentRecord[prop] = moduleEnvironmentRecord.default[prop];
+        }
       }
     }
   };

package/src/pattern-replacement.d.ts

@@ -0,0 +1,6 @@
+export function assertMatchingWildcardCount(pattern: string, replacement: string): void;
+export function makeMultiSubpathReplacer(mapping: PatternDescriptor[] | SubpathMapping): SubpathReplacer;
+import type { PatternDescriptor } from './types/pattern-replacement.js';
+import type { SubpathMapping } from './types/pattern-replacement.js';
+import type { SubpathReplacer } from './types/pattern-replacement.js';
+//# sourceMappingURL=pattern-replacement.d.ts.map

package/src/pattern-replacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-replacement.d.ts","sourceRoot":"","sources":["pattern-replacement.js"],"names":[],"mappings":"AA6BO,qDAJI,MAAM,eACN,MAAM,QAWhB;AAwFM,kDAHI,iBAAiB,EAAE,GAAG,cAAc,GAClC,eAAe,CA0E3B;uCAtLS,gCAAgC;oCAAhC,gCAAgC;qCAAhC,gCAAgC"}

package/src/pattern-replacement.js

@@ -0,0 +1,198 @@
+/**
+ * Provides pattern matching for Node.js-style subpath exports and imports.
+ * Patterns use `*` as a wildcard that matches any string, including across
+ * `/` path separators, matching Node.js semantics.
+ *
+ * @module
+ */
+
+/**
+ * @import {
+ *   SubpathReplacer,
+ *   SubpathReplacerResult,
+ *   SubpathMapping,
+ *   PatternDescriptor,
+ *   ResolvedPattern,
+ * } from './types/pattern-replacement.js'
+ */
+
+const { entries } = Object;
+const { isArray } = Array;
+
+/**
+ * Validates that the pattern and replacement have the same number of wildcards.
+ * Node.js restricts subpath patterns to exactly one `*` on each side.
+ *
+ * @param {string} pattern - Source pattern
+ * @param {string} replacement - Target pattern
+ * @throws {Error} If wildcard counts don't match
+ */
+export const assertMatchingWildcardCount = (pattern, replacement) => {
+  const patternCount = (pattern.match(/\*/g) || []).length;
+  const replacementCount = (replacement.match(/\*/g) || []).length;
+  if (patternCount !== replacementCount) {
+    throw new Error(
+      `Wildcard count mismatch: "${pattern}" has ${patternCount}, "${replacement}" has ${replacementCount}`,
+    );
+  }
+};
+
+/**
+ * Compare two pattern keys using Node.js's PATTERN_KEY_COMPARE ordering.
+ * This prefers the longest prefix before `*`, then the longest full key.
+ * For example, `./foo/*.js` outranks `./foo/*`.
+ *
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+const patternKeyCompare = (a, b) => {
+  const aBaseLength = a.indexOf('*') + 1;
+  const bBaseLength = b.indexOf('*') + 1;
+  if (aBaseLength > bBaseLength) {
+    return -1;
+  }
+  if (bBaseLength > aBaseLength) {
+    return 1;
+  }
+  if (a.length > b.length) {
+    return -1;
+  }
+  if (b.length > a.length) {
+    return 1;
+  }
+  return 0;
+};
+
+/**
+ * Classifies a pattern/replacement pair as exact or wildcard and adds it
+ * to the appropriate collection.
+ *
+ * @param {string} pattern
+ * @param {string | null} replacement
+ * @param {string | undefined} compartment
+ * @param {Map<string, { replacement: string | null, compartment?: string }>} exactEntries
+ * @param {ResolvedPattern[]} wildcardEntries
+ */
+const classifyPatternEntry = (
+  pattern,
+  replacement,
+  compartment,
+  exactEntries,
+  wildcardEntries,
+) => {
+  if (replacement !== null) {
+    assertMatchingWildcardCount(pattern, replacement);
+  }
+
+  const wildcardIndex = pattern.indexOf('*');
+  if (wildcardIndex === -1) {
+    exactEntries.set(pattern, { replacement, compartment });
+    return;
+  }
+
+  const prefix = pattern.slice(0, wildcardIndex);
+  const suffix = pattern.slice(wildcardIndex + 1);
+  let replacementPrefix = null;
+  let replacementSuffix = null;
+  if (replacement !== null) {
+    const replacementWildcardIndex = replacement.indexOf('*');
+    replacementPrefix = replacement.slice(0, replacementWildcardIndex);
+    replacementSuffix = replacement.slice(replacementWildcardIndex + 1);
+  }
+  wildcardEntries.push({
+    pattern,
+    prefix,
+    suffix,
+    replacementPrefix,
+    replacementSuffix,
+    compartment,
+  });
+};
+
+/**
+ * Creates a multi-pattern replacer for Node.js-style subpath patterns.
+ *
+ * Patterns are matched by specificity: the pattern with the longest matching
+ * prefix before the `*` wins. Exact entries (no `*`) take precedence over
+ * all wildcard patterns.
+ *
+ * The `*` wildcard matches any substring, including substrings that contain
+ * `/`, matching Node.js semantics.
+ *
+ * @param {PatternDescriptor[] | SubpathMapping} mapping - Pattern to replacement mapping
+ * @returns {SubpathReplacer} Function that matches a specifier and returns the replacement
+ */
+export const makeMultiSubpathReplacer = mapping => {
+  /** @type {Map<string, { replacement: string | null, compartment?: string }>} */
+  const exactEntries = new Map();
+  /** @type {ResolvedPattern[]} */
+  const wildcardEntries = [];
+
+  /** @type {Array<[string, string | null, string | undefined]>} */
+  let normalizedEntries;
+  if (isArray(mapping)) {
+    normalizedEntries = /** @type {typeof normalizedEntries} */ (
+      mapping.map(entry => {
+        if (isArray(entry)) {
+          // [pattern, replacement] tuple
+          return [entry[0], entry[1], undefined];
+        }
+        // PatternDescriptor { from, to, compartment? }
+        return [entry.from, entry.to, entry.compartment];
+      })
+    );
+  } else {
+    normalizedEntries = /** @type {typeof normalizedEntries} */ (
+      entries(mapping).map(([pattern, replacement]) => [
+        pattern,
+        replacement,
+        undefined,
+      ])
+    );
+  }
+
+  for (const [pattern, replacement, compartment] of normalizedEntries) {
+    classifyPatternEntry(
+      pattern,
+      replacement,
+      compartment,
+      exactEntries,
+      wildcardEntries,
+    );
+  }
+
+  // Match Node.js PATTERN_KEY_COMPARE semantics for subpath pattern
+  // precedence: longest prefix before `*`, then longest full pattern key.
+  wildcardEntries.sort((a, b) => patternKeyCompare(a.pattern, b.pattern));
+
+  return specifier => {
+    // Exact entries take precedence
+    const exact = exactEntries.get(specifier);
+    if (exact) {
+      return { result: exact.replacement, compartment: exact.compartment };
+    }
+
+    // Try wildcard patterns in specificity order
+    for (const entry of wildcardEntries) {
+      if (
+        specifier.startsWith(entry.prefix) &&
+        specifier.endsWith(entry.suffix) &&
+        specifier.length >= entry.prefix.length + entry.suffix.length
+      ) {
+        // Null replacement means this path is explicitly excluded.
+        if (entry.replacementPrefix === null) {
+          return { result: null, compartment: entry.compartment };
+        }
+        const captured = specifier.slice(
+          entry.prefix.length,
+          specifier.length - entry.suffix.length,
+        );
+        const result = `${entry.replacementPrefix}${captured}${entry.replacementSuffix}`;
+        return { result, compartment: entry.compartment };
+      }
+    }
+
+    return null;
+  };
+};

package/src/policy-format.d.ts

@@ -1,10 +1,27 @@
+/**
+ * Const string to identify the internal attenuators compartment
+ */
+export const ATTENUATORS_COMPARTMENT: "<ATTENUATORS>";
+export const ENTRY_COMPARTMENT: "$root$";
+export function generateCanonicalName({ isEntry, name, path }: PackageNamingKit): string;
 export const WILDCARD_POLICY_VALUE: "any";
-export function policyLookupHelper(packagePolicy: import("./types.js").PackagePolicy, field: "builtins" | "globals" | "packages", itemName: string): boolean | import("./types.js").AttenuationDefinition;
-export function isAllowingEverything(policyValue: unknown): policyValue is import("./types.js").WildcardPolicy;
-export function isAttenuationDefinition(allegedDefinition: unknown): allegedDefinition is import("./types.js").AttenuationDefinition;
-export function getAttenuatorFromDefinition(attenuationDefinition: import("./types.js").AttenuationDefinition): import("./types.js").UnifiedAttenuationDefinition;
-export function assertPackagePolicy(allegedPackagePolicy: unknown, path: string, url?: string): asserts allegedPackagePolicy is SomePackagePolicy | undefined;
+export function policyLookupHelper(packagePolicy: PackagePolicy, field: PolicyEnforcementField, canonicalName: string): boolean | AttenuationDefinition;
+export function isAllowingEverything(policyValue: unknown): policyValue is WildcardPolicy;
+/**
+ * Type guard for `AttenuationDefinition`
+ */
+export const isAttenuationDefinition: (value: unknown) => value is FullAttenuationDefinition | ImplicitAttenuationDefinition;
+export function getAttenuatorFromDefinition(attenuationDefinition: AttenuationDefinition): UnifiedAttenuationDefinition;
+export function assertPackagePolicy(allegedPackagePolicy: unknown, keypath: string, url?: string): asserts allegedPackagePolicy is SomePackagePolicy | undefined;
 export function assertPolicy(allegedPolicy: unknown): asserts allegedPolicy is (SomePolicy | undefined);
+import type { PackageNamingKit } from './types.js';
+import type { PackagePolicy } from './types.js';
+import type { PolicyEnforcementField } from './types.js';
+import type { AttenuationDefinition } from './types.js';
+import type { WildcardPolicy } from './types.js';
+import type { FullAttenuationDefinition } from './types.js';
+import type { ImplicitAttenuationDefinition } from './types.js';
+import type { UnifiedAttenuationDefinition } from './types.js';
 import type { SomePackagePolicy } from './types.js';
 import type { SomePolicy } from './types.js';
 //# sourceMappingURL=policy-format.d.ts.map

package/src/policy-format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"policy-format.d.ts","sourceRoot":"","sources":["policy-format.js"],"names":[],"mappings":"AAeA,oCAAqC,KAAK,CAAC;AAepC,kDALI,OAAO,YAAY,EAAE,aAAa,SAClC,UAAU,GAAC,SAAS,GAAC,UAAU,YAC/B,MAAM,GACJ,OAAO,GAAG,OAAO,YAAY,EAAE,qBAAqB,CAyBhE;AAQM,kDAHI,OAAO,GACL,WAAW,IAAI,OAAO,YAAY,EAAE,cAAc,CAGxB;AAOhC,2DAHI,OAAO,GACL,iBAAiB,IAAI,OAAO,YAAY,EAAE,qBAAqB,CAS3E;AAOM,mEAHI,OAAO,YAAY,EAAE,qBAAqB,GACxC,OAAO,YAAY,EAAE,4BAA4B,CAuB7D;AA0CM,0DALI,OAAO,QACP,MAAM,QACN,MAAM,GACJ,QAAQ,oBAAoB,IAAI,iBAAiB,GAAC,SAAS,CA4DvE;AAUM,4CAHI,OAAO,GACL,QAAQ,aAAa,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,CAgC7D;uCA7OgD,YAAY;gCAAZ,YAAY"}
+{"version":3,"file":"policy-format.d.ts","sourceRoot":"","sources":["policy-format.js"],"names":[],"mappings":"AA8BA;;GAEG;AACH,sCAAuC,eAAe,CAAC;AAEvD,gCAAiC,QAAQ,CAAC;AAmBnC,+DAJI,gBAAgB,GACd,MAAM,CAWlB;AAED,oCAAqC,KAAK,CAAC;AAqEpC,kDALI,aAAa,SACb,sBAAsB,iBACtB,MAAM,GACJ,OAAO,GAAG,qBAAqB,CA2B3C;AAQM,kDAHI,OAAO,GACL,WAAW,IAAI,cAAc,CAGH;AA6EvC;;GAEG;AACH,6HAGG;AAQI,mEAHI,qBAAqB,GACnB,4BAA4B,CAwBxC;AAqGM,0DALI,OAAO,WACP,MAAM,QACN,MAAM,GACJ,QAAQ,oBAAoB,IAAI,iBAAiB,GAAC,SAAS,CA0DvE;AAUM,4CAHI,OAAO,GACL,QAAQ,aAAa,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC,CAiC7D;sCAvcQ,YAAY;mCAAZ,YAAY;4CAAZ,YAAY;2CAAZ,YAAY;oCAAZ,YAAY;+CAAZ,YAAY;mDAAZ,YAAY;kDAAZ,YAAY;uCAAZ,YAAY;gCAAZ,YAAY"}