@weborigami/async-tree 0.0.72 → 0.1.0

package/browser.js

@@ -1,13 +1,4 @@
 // Exports for browser
 
-export { default as DeferredTree } from "./src/DeferredTree.js";
-// Skip FileTree.js, which is Node.js only.
-export { default as BrowserFileTree } from "./src/BrowserFileTree.js";
-export { default as FunctionTree } from "./src/FunctionTree.js";
-export * as keysJson from "./src/jsonKeys.js";
-export { default as MapTree } from "./src/MapTree.js";
-export { default as ObjectTree } from "./src/ObjectTree.js";
-export { default as SetTree } from "./src/SetTree.js";
-export { default as SiteTree } from "./src/SiteTree.js";
-export * as Tree from "./src/Tree.js";
-export * from "./src/utilities.js";
+export * from "./shared.js";
+export { default as BrowserFileTree } from "./src/drivers/BrowserFileTree.js";

package/index.ts

@@ -43,6 +43,15 @@ export type Treelike =
   NativeTreelike |
   Unpackable<NativeTreelike>;
 
+export type TreeMapOptions = {
+  deep?: boolean;
+  description?: string;
+  needsSourceValue?: boolean;
+  inverseKey?: KeyFn;
+  key?: KeyFn;
+  value?: ValueKeyFn;
+};
+  
 export type TreeTransform = (treelike: Treelike) => AsyncTree;
 
 export type TypedArray =

package/main.js

@@ -1,39 +1,5 @@
 // Exports for Node.js
 
-export { default as DeferredTree } from "./src/DeferredTree.js";
-export { default as FileTree } from "./src/FileTree.js";
-export { default as FunctionTree } from "./src/FunctionTree.js";
-export { default as MapTree } from "./src/MapTree.js";
-// Skip BrowserFileTree.js, which is browser-only.
-export { default as calendarTree } from "./src/calendarTree.js";
-export { default as DeepMapTree } from "./src/DeepMapTree.js";
-export { default as ExplorableSiteTree } from "./src/ExplorableSiteTree.js";
-export { DeepObjectTree, ObjectTree, Tree } from "./src/internal.js";
-export * as jsonKeys from "./src/jsonKeys.js";
-export { default as cache } from "./src/operations/cache.js";
-export { default as concat } from "./src/operations/concat.js";
-export { default as deepMerge } from "./src/operations/deepMerge.js";
-export { default as deepTake } from "./src/operations/deepTake.js";
-export { default as deepTakeFn } from "./src/operations/deepTakeFn.js";
-export { default as deepValues } from "./src/operations/deepValues.js";
-export { default as deepValuesIterator } from "./src/operations/deepValuesIterator.js";
-export { default as group } from "./src/operations/group.js";
-export { default as groupFn } from "./src/operations/groupFn.js";
-export { default as map } from "./src/operations/map.js";
-export { default as merge } from "./src/operations/merge.js";
-export { default as scope } from "./src/operations/scope.js";
-export { default as sort } from "./src/operations/sort.js";
-export { default as take } from "./src/operations/take.js";
-export { default as SetTree } from "./src/SetTree.js";
-export { default as SiteTree } from "./src/SiteTree.js";
-export * as symbols from "./src/symbols.js";
-export * as trailingSlash from "./src/trailingSlash.js";
-export { default as cachedKeyFunctions } from "./src/transforms/cachedKeyFunctions.js";
-export { default as deepReverse } from "./src/transforms/deepReverse.js";
-export { default as invokeFunctions } from "./src/transforms/invokeFunctions.js";
-export { default as keyFunctionsForExtensions } from "./src/transforms/keyFunctionsForExtensions.js";
-export { default as mapFn } from "./src/transforms/mapFn.js";
-export { default as reverse } from "./src/transforms/reverse.js";
-export { default as sortFn } from "./src/transforms/sortFn.js";
-export { default as takeFn } from "./src/transforms/takeFn.js";
-export * from "./src/utilities.js";
+export * from "./shared.js";
+export { default as FileTree } from "./src/drivers/FileTree.js";
+export * as extension from "./src/extension.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weborigami/async-tree",
-  "version": "0.0.72",
+  "version": "0.1.0",
   "description": "Asynchronous tree drivers based on standard JavaScript classes",
   "type": "module",
   "main": "./main.js",
@@ -11,7 +11,7 @@
     "typescript": "5.6.2"
   },
   "dependencies": {
-    "@weborigami/types": "0.0.72"
+    "@weborigami/types": "0.1.0"
   },
   "scripts": {
     "test": "node --test --test-reporter=spec",

package/shared.js

@@ -0,0 +1,32 @@
+// Exports for both Node.js and browser
+
+export { default as calendarTree } from "./src/drivers/calendarTree.js";
+export { default as DeepMapTree } from "./src/drivers/DeepMapTree.js";
+export { default as DeferredTree } from "./src/drivers/DeferredTree.js";
+export { default as ExplorableSiteTree } from "./src/drivers/ExplorableSiteTree.js";
+export { default as FunctionTree } from "./src/drivers/FunctionTree.js";
+export { default as MapTree } from "./src/drivers/MapTree.js";
+export { default as SetTree } from "./src/drivers/SetTree.js";
+export { default as SiteTree } from "./src/drivers/SiteTree.js";
+export { DeepObjectTree, ObjectTree, Tree } from "./src/internal.js";
+export * as jsonKeys from "./src/jsonKeys.js";
+export { default as cache } from "./src/operations/cache.js";
+export { default as cachedKeyFunctions } from "./src/operations/cachedKeyFunctions.js";
+export { default as concat } from "./src/operations/concat.js";
+export { default as deepMerge } from "./src/operations/deepMerge.js";
+export { default as deepReverse } from "./src/operations/deepReverse.js";
+export { default as deepTake } from "./src/operations/deepTake.js";
+export { default as deepValues } from "./src/operations/deepValues.js";
+export { default as deepValuesIterator } from "./src/operations/deepValuesIterator.js";
+export { default as group } from "./src/operations/group.js";
+export { default as invokeFunctions } from "./src/operations/invokeFunctions.js";
+export { default as keyFunctionsForExtensions } from "./src/operations/keyFunctionsForExtensions.js";
+export { default as map } from "./src/operations/map.js";
+export { default as merge } from "./src/operations/merge.js";
+export { default as reverse } from "./src/operations/reverse.js";
+export { default as scope } from "./src/operations/scope.js";
+export { default as sort } from "./src/operations/sort.js";
+export { default as take } from "./src/operations/take.js";
+export * as symbols from "./src/symbols.js";
+export * as trailingSlash from "./src/trailingSlash.js";
+export * from "./src/utilities.js";

package/src/Tree.d.ts

@@ -1,5 +1,5 @@
 import type { AsyncMutableTree, AsyncTree } from "@weborigami/types";
-import { PlainObject, ReduceFn, Treelike, ValueKeyFn } from "../index.ts";
+import { PlainObject, ReduceFn, Treelike, TreeMapOptions, ValueKeyFn } from "../index.ts";
 
 export function assign(target: Treelike, source: Treelike): Promise<AsyncTree>;
 export function clear(AsyncTree: AsyncMutableTree): Promise<void>;
@@ -11,7 +11,7 @@ export function isAsyncMutableTree(obj: any): obj is AsyncMutableTree;
 export function isAsyncTree(obj: any): obj is AsyncTree;
 export function isTraversable(obj: any): boolean;
 export function isTreelike(obj: any): obj is Treelike;
-export function map(tree: Treelike, valueFn: ValueKeyFn): AsyncTree;
+export function map(tree: Treelike, options: TreeMapOptions|ValueKeyFn): AsyncTree;
 export function mapReduce(tree: Treelike, mapFn: ValueKeyFn | null, reduceFn: ReduceFn): Promise<any>;
 export function paths(tree: Treelike, base?: string): string[];
 export function plain(tree: Treelike): Promise<PlainObject>;

package/src/Tree.js

@@ -1,16 +1,17 @@
-import DeferredTree from "./DeferredTree.js";
-import FunctionTree from "./FunctionTree.js";
-import MapTree from "./MapTree.js";
-import SetTree from "./SetTree.js";
+import DeferredTree from "./drivers/DeferredTree.js";
+import FunctionTree from "./drivers/FunctionTree.js";
+import MapTree from "./drivers/MapTree.js";
+import SetTree from "./drivers/SetTree.js";
 import { DeepObjectTree, ObjectTree } from "./internal.js";
+import * as symbols from "./symbols.js";
 import * as trailingSlash from "./trailingSlash.js";
-import mapTransform from "./transforms/mapFn.js";
 import * as utilities from "./utilities.js";
 import {
   castArrayLike,
   isPacked,
   isPlainObject,
   isUnpackable,
+  toPlainValue,
 } from "./utilities.js";
 
 /**
@@ -67,10 +68,9 @@ export async function assign(target, source) {
  * @param {AsyncMutableTree} tree
  */
 export async function clear(tree) {
-  // @ts-ignore
-  for (const key of await tree.keys()) {
-    await tree.set(key, undefined);
-  }
+  const keys = Array.from(await tree.keys());
+  const promises = keys.map((key) => tree.set(key, undefined));
+  await Promise.all(promises);
 }
 
 /**
@@ -114,7 +114,7 @@ export async function forEach(tree, callbackFn) {
  * @returns {AsyncTree}
  */
 export function from(object, options = {}) {
-  const deep = options.deep ?? false;
+  const deep = options.deep ?? object[symbols.deep];
   let tree;
   if (isAsyncTree(object)) {
     // Argument already supports the tree interface.
@@ -247,10 +247,7 @@ export function isTreelike(obj) {
  * @param {Treelike} treelike
  * @param {ValueKeyFn} valueFn
  */
-export function map(treelike, valueFn) {
-  const tree = from(treelike);
-  return mapTransform({ deep: true, value: valueFn })(tree);
-}
+export { default as map } from "./operations/map.js";
 
 /**
  * Map and reduce a tree.
@@ -327,10 +324,10 @@ export async function paths(treelike, base = "") {
  * @returns {Promise<PlainObject|Array>}
  */
 export async function plain(treelike) {
-  return mapReduce(treelike, null, (values, keys, tree) => {
+  return mapReduce(treelike, toPlainValue, (values, keys, tree) => {
     // Special case for an empty tree: if based on array, return array.
     if (tree instanceof ObjectTree && keys.length === 0) {
-      return tree.object instanceof Array ? [] : {};
+      return /** @type {any} */ (tree).object instanceof Array ? [] : {};
     }
     // Normalize slashes in keys.
     keys = keys.map(trailingSlash.remove);

package/src/{BrowserFileTree.js → drivers/BrowserFileTree.js}

@@ -1,11 +1,11 @@
-import * as trailingSlash from "../src/trailingSlash.js";
-import { Tree } from "./internal.js";
+import { Tree } from "../internal.js";
+import * as trailingSlash from "../trailingSlash.js";
 import {
   hiddenFileNames,
   isStringLike,
   naturalOrder,
   setParent,
-} from "./utilities.js";
+} from "../utilities.js";
 
 const TypedArray = Object.getPrototypeOf(Uint8Array);
 

package/src/{DeepMapTree.js → drivers/DeepMapTree.js}

@@ -1,4 +1,4 @@
-import { Tree } from "./internal.js";
+import { Tree } from "../internal.js";
 import MapTree from "./MapTree.js";
 
 export default class DeepMapTree extends MapTree {

package/src/{DeepObjectTree.js → drivers/DeepObjectTree.js}

@@ -1,5 +1,5 @@
-import { ObjectTree, Tree } from "./internal.js";
-import { isPlainObject } from "./utilities.js";
+import { ObjectTree, Tree } from "../internal.js";
+import { isPlainObject } from "../utilities.js";
 
 export default class DeepObjectTree extends ObjectTree {
   async get(key) {

package/src/{DeferredTree.js → drivers/DeferredTree.js}

@@ -1,4 +1,4 @@
-import { Tree } from "./internal.js";
+import { Tree } from "../internal.js";
 
 /**
  * A tree that is loaded lazily.
@@ -21,7 +21,7 @@ export default class DeferredTree {
     this.treePromise = null;
     this._tree = null;
     this._parentUntilLoaded = null;
-    this._deep = options?.deep ?? false;
+    this._deep = options?.deep;
   }
 
   async get(key) {
@@ -62,7 +62,9 @@ export default class DeferredTree {
 
     // Use a promise to ensure the treelike is only converted to a tree once.
     this.treePromise ??= this.loadResult().then((treelike) => {
-      this._tree = Tree.from(treelike, { deep: this._deep });
+      const options =
+        this._deep !== undefined ? { deep: this._deep } : undefined;
+      this._tree = Tree.from(treelike, options);
       if (this._parentUntilLoaded) {
         // Now that the tree has been loaded, we can set its parent if it hasn't
         // already been set.

package/src/{FileTree.js → drivers/FileTree.js}

@@ -1,8 +1,8 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { Tree } from "./internal.js";
-import * as trailingSlash from "./trailingSlash.js";
+import { Tree } from "../internal.js";
+import * as trailingSlash from "../trailingSlash.js";
 import {
   getRealmObjectPrototype,
   hiddenFileNames,
@@ -10,7 +10,7 @@ import {
   isPlainObject,
   naturalOrder,
   setParent,
-} from "./utilities.js";
+} from "../utilities.js";
 
 /**
  * A file system tree via the Node file system API.

package/src/{FunctionTree.js → drivers/FunctionTree.js}

@@ -1,4 +1,4 @@
-import { setParent } from "./utilities.js";
+import { setParent } from "../utilities.js";
 
 /**
  * A tree defined by a function and an optional domain.

package/src/{MapTree.js → drivers/MapTree.js}

@@ -1,6 +1,6 @@
-import { Tree } from "./internal.js";
-import * as trailingSlash from "./trailingSlash.js";
-import { setParent } from "./utilities.js";
+import { Tree } from "../internal.js";
+import * as trailingSlash from "../trailingSlash.js";
+import { setParent } from "../utilities.js";
 
 /**
  * A tree backed by a JavaScript `Map` object.

package/src/{ObjectTree.js → drivers/ObjectTree.js}

@@ -1,7 +1,7 @@
-import { Tree } from "./internal.js";
-import * as symbols from "./symbols.js";
-import * as trailingSlash from "./trailingSlash.js";
-import { getRealmObjectPrototype, setParent } from "./utilities.js";
+import { Tree } from "../internal.js";
+import * as symbols from "../symbols.js";
+import * as trailingSlash from "../trailingSlash.js";
+import { getRealmObjectPrototype, setParent } from "../utilities.js";
 
 /**
  * A tree defined by a plain object or array.

package/src/{SetTree.js → drivers/SetTree.js}

@@ -1,4 +1,4 @@
-import { setParent } from "./utilities.js";
+import { setParent } from "../utilities.js";
 
 /**
  * A tree of Set objects.

package/src/{SiteTree.js → drivers/SiteTree.js}

@@ -1,5 +1,5 @@
-import * as trailingSlash from "./trailingSlash.js";
-import { setParent } from "./utilities.js";
+import * as trailingSlash from "../trailingSlash.js";
+import { setParent } from "../utilities.js";
 
 /**
  * A tree of values obtained via HTTP/HTTPS calls. These values will be strings

package/src/{calendarTree.js → drivers/calendarTree.js}

@@ -1,4 +1,4 @@
-import * as trailingSlash from "./trailingSlash.js";
+import * as trailingSlash from "../trailingSlash.js";
 
 /**
  * Return a tree of years, months, and days from a start date to an end date.

package/src/extension.js

@@ -0,0 +1,140 @@
+import * as trailingSlash from "./trailingSlash.js";
+import { isStringLike, toString } from "./utilities.js";
+
+/**
+ * Replicate the logic of Node POSIX path.extname at
+ * https://github.com/nodejs/node/blob/main/lib/path.js so that we can use this
+ * in the browser.
+ *
+ * @param {string} path
+ * @returns {string}
+ */
+export function extname(path) {
+  if (typeof path !== "string") {
+    throw new TypeError(`Expected a string, got ${typeof path}`);
+  }
+  let startDot = -1;
+  let startPart = 0;
+  let end = -1;
+  let matchedSlash = true;
+  // Track the state of characters (if any) we see before our first dot and
+  // after any path separator we find
+  let preDotState = 0;
+  for (let i = path.length - 1; i >= 0; --i) {
+    const char = path[i];
+    if (char === "/") {
+      // If we reached a path separator that was not part of a set of path
+      // separators at the end of the string, stop now
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1) {
+      // We saw the first non-path separator, mark this as the end of our
+      // extension
+      matchedSlash = false;
+      end = i + 1;
+    }
+    if (char === ".") {
+      // If this is our first dot, mark it as the start of our extension
+      if (startDot === -1) startDot = i;
+      else if (preDotState !== 1) preDotState = 1;
+    } else if (startDot !== -1) {
+      // We saw a non-dot and non-path separator before our dot, so we should
+      // have a good chance at having a non-empty extension
+      preDotState = -1;
+    }
+  }
+
+  if (
+    startDot === -1 ||
+    end === -1 ||
+    // We saw a non-dot character immediately before the dot
+    preDotState === 0 ||
+    // The (right-most) trimmed path component is exactly '..'
+    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+  ) {
+    return "";
+  }
+  return path.slice(startDot, end);
+}
+
+/**
+ * See if the key ends with the given extension. If it does, return the base
+ * name without the extension; if it doesn't return null.
+ *
+ * If the extension is empty, the key must not have an extension to match.
+ *
+ * If the extension is a slash, then the key must end with a slash for the match
+ * to succeed. Otherwise, a trailing slash in the key is ignored for purposes of
+ * comparison to comply with the way Origami can unpack files. Example: the keys
+ * "data.json" and "data.json/" are treated equally.
+ *
+ * This uses a different, more general interpretation of "extension" to mean any
+ * suffix, rather than Node's interpretation in `extname`. In particular, this
+ * will match a multi-part extension like ".foo.bar" that contains more than one
+ * dot.
+ */
+export function match(key, ext) {
+  if (!isStringLike(key)) {
+    return null;
+  }
+  key = toString(key);
+
+  if (ext === "/") {
+    return trailingSlash.has(key) ? trailingSlash.remove(key) : null;
+  }
+
+  // Key matches if it ends with the same extension
+  const normalized = trailingSlash.remove(key);
+  if (normalized.endsWith(ext)) {
+    const removed =
+      ext.length > 0 ? normalized.slice(0, -ext.length) : normalized;
+    return trailingSlash.toggle(removed, trailingSlash.has(key));
+  }
+
+  // Didn't match
+  return null;
+}
+
+/**
+ * If the given key ends in the source extension (which will generally include a
+ * period), replace that extension with the result extension (which again should
+ * generally include a period). Otherwise, return the key as is.
+ *
+ * If the key ends in a trailing slash, that will be preserved in the result.
+ * Exception: if the source extension is empty, and the key doesn't have an
+ * extension, the result extension will be appended to the key without a slash.
+ *
+ * @param {string} key
+ * @param {string} sourceExtension
+ * @param {string} resultExtension
+ */
+export function replace(key, sourceExtension, resultExtension) {
+  if (!isStringLike(key)) {
+    return null;
+  }
+  key = toString(key);
+
+  if (!match(key, sourceExtension)) {
+    return key;
+  }
+
+  let replaced;
+  const normalizedKey = trailingSlash.remove(key);
+  if (sourceExtension === "") {
+    replaced = normalizedKey + resultExtension;
+    if (!normalizedKey.includes(".")) {
+      return replaced;
+    }
+  } else if (sourceExtension === "/") {
+    return trailingSlash.remove(key) + resultExtension;
+  } else {
+    replaced =
+      normalizedKey.slice(0, -sourceExtension.length) + resultExtension;
+  }
+
+  return trailingSlash.toggle(replaced, trailingSlash.has(key));
+}

package/src/internal.js

@@ -7,9 +7,10 @@
 // About this pattern:
 // https://medium.com/visual-development/how-to-fix-nasty-circular-dependency-issues-once-and-for-all-in-javascript-typescript-a04c987cf0de
 //
+// Note: to avoid having VS Code auto-sort the imports, keep lines between them.
 
 export * as Tree from "./Tree.js";
 
-export { default as ObjectTree } from "./ObjectTree.js";
+export { default as ObjectTree } from "./drivers/ObjectTree.js";
 
-export { default as DeepObjectTree } from "./DeepObjectTree.js";
+export { default as DeepObjectTree } from "./drivers/DeepObjectTree.js";

package/src/{transforms → operations}/deepReverse.js

@@ -18,7 +18,7 @@ export default function deepReverse(treelike) {
     throw error;
   }
 
-  const tree = Tree.from(treelike);
+  const tree = Tree.from(treelike, { deep: true });
   return {
     async get(key) {
       let value = await tree.get(key);

package/src/operations/deepTake.js

@@ -1,4 +1,4 @@
-import deepTakeFn from "./deepTakeFn.js";
+import { Tree } from "../internal.js";
 
 /**
  * Returns a function that traverses a tree deeply and returns the values of the
@@ -10,6 +10,33 @@ import deepTakeFn from "./deepTakeFn.js";
  * @param {import("../../index.ts").Treelike} treelike
  * @param {number} count
  */
-export default function deepTake(treelike, count) {
-  return deepTakeFn(count)(treelike);
+export default async function deepTake(treelike, count) {
+  if (!treelike) {
+    const error = new TypeError(`deepTake: The tree isn't defined.`);
+    /** @type {any} */ (error).position = 0;
+    throw error;
+  }
+
+  const tree = await Tree.from(treelike, { deep: true });
+  const { values } = await traverse(tree, count);
+  return Tree.from(values, { deep: true });
+}
+
+async function traverse(tree, count) {
+  const values = [];
+  for (const key of await tree.keys()) {
+    if (count <= 0) {
+      break;
+    }
+    let value = await tree.get(key);
+    if (Tree.isAsyncTree(value)) {
+      const traversed = await traverse(value, count);
+      values.push(...traversed.values);
+      count = traversed.count;
+    } else {
+      values.push(value);
+      count--;
+    }
+  }
+  return { count, values };
 }

package/src/operations/group.js

@@ -1,4 +1,4 @@
-import groupFn from "./groupFn.js";
+import { ObjectTree, Tree } from "../internal.js";
 
 /**
  * Given a function that returns a grouping key for a value, returns a transform
@@ -7,6 +7,47 @@ import groupFn from "./groupFn.js";
  * @param {import("../../index.ts").Treelike} treelike
  * @param {import("../../index.ts").ValueKeyFn} groupKeyFn
  */
-export default function group(treelike, groupKeyFn) {
-  return groupFn(groupKeyFn)(treelike);
+export default async function group(treelike, groupKeyFn) {
+  if (!treelike) {
+    const error = new TypeError(`groupBy: The tree to group isn't defined.`);
+    /** @type {any} */ (error).position = 0;
+    throw error;
+  }
+
+  const tree = Tree.from(treelike);
+
+  const keys = Array.from(await tree.keys());
+
+  // Are all the keys integers?
+  const isArray = keys.every((key) => !Number.isNaN(parseInt(key)));
+
+  const result = {};
+  for (const key of await tree.keys()) {
+    const value = await tree.get(key);
+
+    // Get the groups for this value.
+    let groups = await groupKeyFn(value, key, tree);
+    if (!groups) {
+      continue;
+    }
+
+    if (!Tree.isTreelike(groups)) {
+      // A single value was returned
+      groups = [groups];
+    }
+    groups = Tree.from(groups);
+
+    // Add the value to each group.
+    for (const group of await Tree.values(groups)) {
+      if (isArray) {
+        result[group] ??= [];
+        result[group].push(value);
+      } else {
+        result[group] ??= {};
+        result[group][key] = value;
+      }
+    }
+  }
+
+  return new ObjectTree(result);
 }

package/src/operations/keyFunctionsForExtensions.js

@@ -0,0 +1,48 @@
+import * as extension from "../extension.js";
+import * as trailingSlash from "../trailingSlash.js";
+
+/**
+ * Given a source resultExtension and a result resultExtension, return a pair of key
+ * functions that map between them.
+ *
+ * The resulting `inverseKey` and `key` functions are compatible with those
+ * expected by map and other transforms.
+ *
+ * @typedef {import("@weborigami/types").AsyncTree} AsyncTree
+ * @param {{ resultExtension?: string, sourceExtension: string }}
+ * options
+ */
+export default function keyFunctionsForExtensions({
+  resultExtension,
+  sourceExtension,
+}) {
+  if (resultExtension === undefined) {
+    resultExtension = sourceExtension;
+  }
+
+  checkDeprecatedExtensionWithoutDot(resultExtension);
+  checkDeprecatedExtensionWithoutDot(sourceExtension);
+
+  return {
+    async inverseKey(resultKey, tree) {
+      // Remove trailing slash so that mapFn won't inadvertently unpack files.
+      const baseKey = trailingSlash.remove(resultKey);
+      const basename = extension.match(baseKey, resultExtension);
+      return basename ? `${basename}${sourceExtension}` : undefined;
+    },
+
+    async key(sourceKey, tree) {
+      return extension.match(sourceKey, sourceExtension)
+        ? extension.replace(sourceKey, sourceExtension, resultExtension)
+        : undefined;
+    },
+  };
+}
+
+function checkDeprecatedExtensionWithoutDot(extension) {
+  if (extension && extension !== "/" && !extension.startsWith(".")) {
+    throw new RangeError(
+      `map: Warning: the extension "${extension}" should start with a period.`
+    );
+  }
+}