@aussieljk/forkbook 0.0.1-5 → 0.0.1-7

package/dist/_node-chunks/{chunk-PHXCOTMO.js → chunk-CDFQORVD.js}

@@ -1,62 +1,17 @@
-import CJS_COMPAT_NODE_URL_1qqypd7gt14 from 'node:url';
-import CJS_COMPAT_NODE_PATH_1qqypd7gt14 from 'node:path';
-import CJS_COMPAT_NODE_MODULE_1qqypd7gt14 from "node:module";
+import CJS_COMPAT_NODE_URL_j88npgqhy9 from 'node:url';
+import CJS_COMPAT_NODE_PATH_j88npgqhy9 from 'node:path';
+import CJS_COMPAT_NODE_MODULE_j88npgqhy9 from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_1qqypd7gt14.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_1qqypd7gt14.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_1qqypd7gt14.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_j88npgqhy9.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_j88npgqhy9.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_j88npgqhy9.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Forkbook's esbuild configuration
 // ------------------------------------------------------------
 import {
-  createServiceRuntime,
-  getRegisteredServices,
-  getService,
-  registerService,
-  resolveStaticPath,
-  serviceRegistryApi,
-  validateSchema
-} from "./chunk-J64XMUPF.js";
-import {
-  argumentsTag,
-  arrayBufferTag,
-  arrayTag,
-  booleanTag,
-  dataViewTag,
-  dateTag,
-  float32ArrayTag,
-  float64ArrayTag,
-  getSymbols,
-  getTag,
-  int16ArrayTag,
-  int32ArrayTag,
-  int8ArrayTag,
-  isBuffer,
-  isPlainObject,
-  isPrimitive,
-  isTypedArray,
-  mapTag,
-  numberTag,
-  objectTag,
-  regexpTag,
-  setTag,
-  stringTag,
-  symbolTag,
-  uint16ArrayTag,
-  uint32ArrayTag,
-  uint8ArrayTag,
-  uint8ClampedArrayTag
-} from "./chunk-N4FLP7AO.js";
-import {
-  any,
-  up,
-  up2
-} from "./chunk-SJZQ44OR.js";
-import {
-  __commonJS,
-  __toESM
-} from "./chunk-TZ2TZW2K.js";
+  __commonJS
+} from "./chunk-NLPC2DDQ.js";
 
 // ../../node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS({
@@ -757,9 +712,9 @@ var require_parse = __commonJS({
           if (opts.posix !== !1 && value === ":") {
             let inner = prev.value.slice(1);
             if (inner.includes("[") && (prev.posix = !0, inner.includes(":"))) {
-              let idx = prev.value.lastIndexOf("["), pre = prev.value.slice(0, idx), rest2 = prev.value.slice(idx + 2), posix2 = POSIX_REGEX_SOURCE[rest2];
-              if (posix2) {
-                prev.value = pre + posix2, state.backtrack = !0, advance(), !bos.output && tokens.indexOf(prev) === 1 && (bos.output = ONE_CHAR);
+              let idx = prev.value.lastIndexOf("["), pre = prev.value.slice(0, idx), rest2 = prev.value.slice(idx + 2), posix = POSIX_REGEX_SOURCE[rest2];
+              if (posix) {
+                prev.value = pre + posix, state.backtrack = !0, advance(), !bos.output && tokens.indexOf(prev) === 1 && (bos.output = ONE_CHAR);
                 continue;
               }
             }
@@ -1079,9 +1034,9 @@ var require_parse = __commonJS({
 var require_picomatch = __commonJS({
   "../../node_modules/picomatch/lib/picomatch.js"(exports, module) {
     "use strict";
-    var scan = require_scan(), parse = require_parse(), utils = require_utils(), constants = require_constants(), isObject = (val) => val && typeof val == "object" && !Array.isArray(val), picomatch2 = (glob, options, returnState = !1) => {
+    var scan = require_scan(), parse = require_parse(), utils = require_utils(), constants = require_constants(), isObject = (val) => val && typeof val == "object" && !Array.isArray(val), picomatch = (glob, options, returnState = !1) => {
       if (Array.isArray(glob)) {
-        let fns = glob.map((input) => picomatch2(input, options, returnState));
+        let fns = glob.map((input) => picomatch(input, options, returnState));
         return (str) => {
           for (let isMatch of fns) {
             let state2 = isMatch(str);
@@ -1093,46 +1048,46 @@ var require_picomatch = __commonJS({
       let isState = isObject(glob) && glob.tokens && glob.input;
       if (glob === "" || typeof glob != "string" && !isState)
         throw new TypeError("Expected pattern to be a non-empty string");
-      let opts = options || {}, posix2 = opts.windows, regex = isState ? picomatch2.compileRe(glob, options) : picomatch2.makeRe(glob, options, !1, !0), state = regex.state;
+      let opts = options || {}, posix = opts.windows, regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, !1, !0), state = regex.state;
       delete regex.state;
       let isIgnored = () => !1;
       if (opts.ignore) {
         let ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
-        isIgnored = picomatch2(opts.ignore, ignoreOpts, returnState);
+        isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
       }
       let matcher = (input, returnObject = !1) => {
-        let { isMatch, match, output } = picomatch2.test(input, regex, options, { glob, posix: posix2 }), result = { glob, state, regex, posix: posix2, input, output, match, isMatch };
+        let { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix }), result = { glob, state, regex, posix, input, output, match, isMatch };
         return typeof opts.onResult == "function" && opts.onResult(result), isMatch === !1 ? (result.isMatch = !1, returnObject ? result : !1) : isIgnored(input) ? (typeof opts.onIgnore == "function" && opts.onIgnore(result), result.isMatch = !1, returnObject ? result : !1) : (typeof opts.onMatch == "function" && opts.onMatch(result), returnObject ? result : !0);
       };
       return returnState && (matcher.state = state), matcher;
     };
-    picomatch2.test = (input, regex, options, { glob, posix: posix2 } = {}) => {
+    picomatch.test = (input, regex, options, { glob, posix } = {}) => {
       if (typeof input != "string")
         throw new TypeError("Expected input to be a string");
       if (input === "")
         return { isMatch: !1, output: "" };
-      let opts = options || {}, format = opts.format || (posix2 ? utils.toPosixSlashes : null), match = input === glob, output = match && format ? format(input) : input;
-      return match === !1 && (output = format ? format(input) : input, match = output === glob), (match === !1 || opts.capture === !0) && (opts.matchBase === !0 || opts.basename === !0 ? match = picomatch2.matchBase(input, regex, options, posix2) : match = regex.exec(output)), { isMatch: !!match, match, output };
+      let opts = options || {}, format = opts.format || (posix ? utils.toPosixSlashes : null), match = input === glob, output = match && format ? format(input) : input;
+      return match === !1 && (output = format ? format(input) : input, match = output === glob), (match === !1 || opts.capture === !0) && (opts.matchBase === !0 || opts.basename === !0 ? match = picomatch.matchBase(input, regex, options, posix) : match = regex.exec(output)), { isMatch: !!match, match, output };
     };
-    picomatch2.matchBase = (input, glob, options, posix2 = options && options.windows) => (glob instanceof RegExp ? glob : picomatch2.makeRe(glob, options)).test(utils.basename(input, { windows: posix2 }));
-    picomatch2.isMatch = (str, patterns, options) => picomatch2(patterns, options)(str);
-    picomatch2.parse = (pattern, options) => Array.isArray(pattern) ? pattern.map((p) => picomatch2.parse(p, options)) : parse(pattern, { ...options, fastpaths: !1 });
-    picomatch2.scan = (input, options) => scan(input, options);
-    picomatch2.compileRe = (state, options, returnOutput = !1, returnState = !1) => {
+    picomatch.matchBase = (input, glob, options, posix = options && options.windows) => (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(utils.basename(input, { windows: posix }));
+    picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+    picomatch.parse = (pattern, options) => Array.isArray(pattern) ? pattern.map((p) => picomatch.parse(p, options)) : parse(pattern, { ...options, fastpaths: !1 });
+    picomatch.scan = (input, options) => scan(input, options);
+    picomatch.compileRe = (state, options, returnOutput = !1, returnState = !1) => {
       if (returnOutput === !0)
         return state.output;
       let opts = options || {}, prepend = opts.contains ? "" : "^", append = opts.contains ? "" : "$", source = `${prepend}(?:${state.output})${append}`;
       state && state.negated === !0 && (source = `^(?!${source}).*$`);
-      let regex = picomatch2.toRegex(source, options);
+      let regex = picomatch.toRegex(source, options);
       return returnState === !0 && (regex.state = state), regex;
     };
-    picomatch2.makeRe = (input, options = {}, returnOutput = !1, returnState = !1) => {
+    picomatch.makeRe = (input, options = {}, returnOutput = !1, returnState = !1) => {
       if (!input || typeof input != "string")
         throw new TypeError("Expected a non-empty string");
       let parsed = { negated: !1, fastpaths: !0 };
-      return options.fastpaths !== !1 && (input[0] === "." || input[0] === "*") && (parsed.output = parse.fastpaths(input, options)), parsed.output || (parsed = parse(input, options)), picomatch2.compileRe(parsed, options, returnOutput, returnState);
+      return options.fastpaths !== !1 && (input[0] === "." || input[0] === "*") && (parsed.output = parse.fastpaths(input, options)), parsed.output || (parsed = parse(input, options)), picomatch.compileRe(parsed, options, returnOutput, returnState);
     };
-    picomatch2.toRegex = (source, options) => {
+    picomatch.toRegex = (source, options) => {
       try {
         let opts = options || {};
         return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
@@ -1141,8 +1096,8 @@ var require_picomatch = __commonJS({
         return /$^/;
       }
     };
-    picomatch2.constants = constants;
-    module.exports = picomatch2;
+    picomatch.constants = constants;
+    module.exports = picomatch;
   }
 });
 
@@ -1151,884 +1106,14 @@ var require_picomatch2 = __commonJS({
   "../../node_modules/picomatch/index.js"(exports, module) {
     "use strict";
     var pico = require_picomatch(), utils = require_utils();
-    function picomatch2(glob, options, returnState = !1) {
+    function picomatch(glob, options, returnState = !1) {
       return options && (options.windows === null || options.windows === void 0) && (options = { ...options, windows: utils.isWindows() }), pico(glob, options, returnState);
     }
-    Object.assign(picomatch2, pico);
-    module.exports = picomatch2;
+    Object.assign(picomatch, pico);
+    module.exports = picomatch;
   }
 });
 
-// src/shared/open-service/server.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "pathe";
-
-// ../../node_modules/es-toolkit/dist/object/clone.mjs
-function clone(obj) {
-  if (isPrimitive(obj)) return obj;
-  if (Array.isArray(obj) || isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && obj instanceof SharedArrayBuffer) return obj.slice(0);
-  let prototype = Object.getPrototypeOf(obj);
-  if (prototype == null) return Object.assign(Object.create(prototype), obj);
-  let Constructor = prototype.constructor;
-  if (obj instanceof Date || obj instanceof Map || obj instanceof Set) return new Constructor(obj);
-  if (obj instanceof RegExp) {
-    let newRegExp = new Constructor(obj);
-    return newRegExp.lastIndex = obj.lastIndex, newRegExp;
-  }
-  if (obj instanceof DataView) return new Constructor(obj.buffer.slice(0));
-  if (obj instanceof Error) {
-    let newError;
-    return obj instanceof AggregateError ? newError = new Constructor(obj.errors, obj.message, { cause: obj.cause }) : newError = new Constructor(obj.message, { cause: obj.cause }), newError.stack = obj.stack, Object.assign(newError, obj), newError;
-  }
-  return typeof File < "u" && obj instanceof File ? new Constructor([obj], obj.name, {
-    type: obj.type,
-    lastModified: obj.lastModified
-  }) : typeof obj == "object" ? Object.assign(Object.create(prototype), obj) : obj;
-}
-
-// ../../node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
-function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
-  let cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
-  if (cloned !== void 0) return cloned;
-  if (isPrimitive(valueToClone)) return valueToClone;
-  if (stack.has(valueToClone)) return stack.get(valueToClone);
-  if (Array.isArray(valueToClone)) {
-    let result = new Array(valueToClone.length);
-    stack.set(valueToClone, result);
-    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
-    return Object.hasOwn(valueToClone, "index") && (result.index = valueToClone.index), Object.hasOwn(valueToClone, "input") && (result.input = valueToClone.input), result;
-  }
-  if (valueToClone instanceof Date) return new Date(valueToClone.getTime());
-  if (valueToClone instanceof RegExp) {
-    let result = new RegExp(valueToClone.source, valueToClone.flags);
-    return result.lastIndex = valueToClone.lastIndex, result;
-  }
-  if (valueToClone instanceof Map) {
-    let result = /* @__PURE__ */ new Map();
-    stack.set(valueToClone, result);
-    for (let [key, value] of valueToClone) result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
-    return result;
-  }
-  if (valueToClone instanceof Set) {
-    let result = /* @__PURE__ */ new Set();
-    stack.set(valueToClone, result);
-    for (let value of valueToClone) result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
-    return result;
-  }
-  if (isBuffer(valueToClone)) return valueToClone.subarray();
-  if (isTypedArray(valueToClone)) {
-    let result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
-    stack.set(valueToClone, result);
-    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
-    return result;
-  }
-  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && valueToClone instanceof SharedArrayBuffer) return valueToClone.slice(0);
-  if (valueToClone instanceof DataView) {
-    let result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
-    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  if (typeof File < "u" && valueToClone instanceof File) {
-    let result = new File([valueToClone], valueToClone.name, { type: valueToClone.type });
-    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  if (typeof Blob < "u" && valueToClone instanceof Blob) {
-    let result = new Blob([valueToClone], { type: valueToClone.type });
-    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  if (valueToClone instanceof Error) {
-    let result = structuredClone(valueToClone);
-    return stack.set(valueToClone, result), result.message = valueToClone.message, result.name = valueToClone.name, result.stack = valueToClone.stack, result.cause = valueToClone.cause, result.constructor = valueToClone.constructor, copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  if (valueToClone instanceof Boolean) {
-    let result = new Boolean(valueToClone.valueOf());
-    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  if (valueToClone instanceof Number) {
-    let result = new Number(valueToClone.valueOf());
-    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  if (valueToClone instanceof String) {
-    let result = new String(valueToClone.valueOf());
-    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  if (typeof valueToClone == "object" && isCloneableObject(valueToClone)) {
-    let result = Object.create(Object.getPrototypeOf(valueToClone));
-    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
-  }
-  return valueToClone;
-}
-function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
-  let keys = [...Object.keys(source), ...getSymbols(source)];
-  for (let i = 0; i < keys.length; i++) {
-    let key = keys[i], descriptor = Object.getOwnPropertyDescriptor(target, key);
-    (descriptor == null || descriptor.writable) && (target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue));
-  }
-}
-function isCloneableObject(object) {
-  switch (getTag(object)) {
-    case argumentsTag:
-    case arrayTag:
-    case arrayBufferTag:
-    case dataViewTag:
-    case booleanTag:
-    case dateTag:
-    case float32ArrayTag:
-    case float64ArrayTag:
-    case int8ArrayTag:
-    case int16ArrayTag:
-    case int32ArrayTag:
-    case mapTag:
-    case numberTag:
-    case objectTag:
-    case regexpTag:
-    case setTag:
-    case stringTag:
-    case symbolTag:
-    case uint8ArrayTag:
-    case uint8ClampedArrayTag:
-    case uint16ArrayTag:
-    case uint32ArrayTag:
-      return !0;
-    default:
-      return !1;
-  }
-}
-
-// ../../node_modules/es-toolkit/dist/object/cloneDeep.mjs
-function cloneDeep(obj) {
-  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
-}
-
-// ../../node_modules/es-toolkit/dist/_internal/isMergeableValue.mjs
-function isMergeableValue(value) {
-  return isPlainObject(value) || Array.isArray(value);
-}
-
-// ../../node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
-function isUnsafeProperty(key) {
-  return key === "__proto__";
-}
-
-// ../../node_modules/es-toolkit/dist/object/mergeWith.mjs
-function mergeWith(target, source, merge2) {
-  let sourceKeys = Object.keys(source);
-  for (let i = 0; i < sourceKeys.length; i++) {
-    let key = sourceKeys[i];
-    if (isUnsafeProperty(key)) continue;
-    let sourceValue = source[key], targetValue = target[key], merged = merge2(targetValue, sourceValue, key, target, source);
-    merged !== void 0 ? target[key] = merged : isMergeableValue(sourceValue) && isMergeableValue(targetValue) ? target[key] = mergeWith(targetValue, sourceValue, merge2) : Array.isArray(sourceValue) ? target[key] = mergeWith([], sourceValue, merge2) : isPlainObject(sourceValue) ? target[key] = mergeWith({}, sourceValue, merge2) : (targetValue === void 0 || sourceValue !== void 0) && (target[key] = sourceValue);
-  }
-  return target;
-}
-
-// ../../node_modules/es-toolkit/dist/object/toMerged.mjs
-function toMerged(target, source) {
-  return mergeWith(cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
-    if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
-    if (Array.isArray(sourceValue)) return mergeWith([], sourceValue, mergeRecursively);
-    if (isPlainObject(sourceValue)) return mergeWith({}, sourceValue, mergeRecursively);
-  });
-}
-
-// src/shared/open-service/server.ts
-var getService2 = getService;
-function registerService2(definition, registration) {
-  return registerService(definition, registration, { relay: !0 });
-}
-async function buildStaticFiles() {
-  let store = {}, buildTasks = [];
-  for (let service of getRegisteredServices())
-    for (let [queryName, query] of Object.entries(service.queries)) {
-      let { load, staticPath, staticInputs } = query;
-      !staticPath || !load || !staticInputs || buildTasks.push(
-        (async () => {
-          let inputsRuntime = createServiceRuntime(service, { registryApi: serviceRegistryApi }), inputs = await staticInputs(inputsRuntime.loadCtxForStatic);
-          return Promise.all(
-            inputs.map(async (input) => {
-              let buildRuntime = createServiceRuntime(service, {
-                registryApi: serviceRegistryApi
-              }), validatedInput = await validateSchema(query.input, input, {
-                kind: "query",
-                serviceId: service.id,
-                name: queryName,
-                phase: "input"
-              }), path = resolveStaticPath(service.id, queryName, { staticPath }, validatedInput);
-              return await buildRuntime.runLoadOnce(queryName, validatedInput), { path, state: buildRuntime.getStateSnapshot() };
-            })
-          );
-        })()
-      );
-    }
-  let builtStates = (await Promise.all(buildTasks)).flat();
-  for (let { path, state } of builtStates)
-    store[path] = path in store ? toMerged(store[path], state) : state;
-  return store;
-}
-async function writeOpenServiceStaticFiles(outputDir) {
-  let staticStore = await buildStaticFiles();
-  await Promise.all(
-    Object.entries(staticStore).map(async ([relativePath, state]) => {
-      let outputPath = join(outputDir, "services", ...relativePath.split("/"));
-      await mkdir(dirname(outputPath), { recursive: !0 }), await writeFile(outputPath, JSON.stringify(state, null, 2));
-    })
-  );
-}
-
-// src/common/utils/paths.ts
-import { join as join2, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
-
-// ../../node_modules/tinyglobby/dist/index.mjs
-import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
-import { isAbsolute, posix, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-
-// ../../node_modules/fdir/dist/index.mjs
-import { createRequire } from "module";
-import { basename, dirname as dirname2, normalize, relative, resolve, sep } from "path";
-import * as nativeFs from "fs";
-var __require = createRequire(import.meta.url);
-function cleanPath(path) {
-  let normalized = normalize(path);
-  return normalized.length > 1 && normalized[normalized.length - 1] === sep && (normalized = normalized.substring(0, normalized.length - 1)), normalized;
-}
-var SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path, separator) {
-  return path.replace(SLASHES_REGEX, separator);
-}
-var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path) {
-  return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
-}
-function normalizePath(path, options) {
-  let { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options, pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
-  if (resolvePaths && (path = resolve(path)), (normalizePath$1 || pathNeedsCleaning) && (path = cleanPath(path)), path === ".") return "";
-  let needsSeperator = path[path.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
-}
-function joinPathWithBasePath(filename, directoryPath) {
-  return directoryPath + filename;
-}
-function joinPathWithRelativePath(root, options) {
-  return function(filename, directoryPath) {
-    return directoryPath.startsWith(root) ? directoryPath.slice(root.length) + filename : convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
-  };
-}
-function joinPath(filename) {
-  return filename;
-}
-function joinDirectoryPath(filename, directoryPath, separator) {
-  return directoryPath + filename + separator;
-}
-function build$7(root, options) {
-  let { relativePaths, includeBasePath } = options;
-  return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
-}
-function pushDirectoryWithRelativePath(root) {
-  return function(directoryPath, paths) {
-    paths.push(directoryPath.substring(root.length) || ".");
-  };
-}
-function pushDirectoryFilterWithRelativePath(root) {
-  return function(directoryPath, paths, filters) {
-    let relativePath = directoryPath.substring(root.length) || ".";
-    filters.every((filter) => filter(relativePath, !0)) && paths.push(relativePath);
-  };
-}
-var pushDirectory = (directoryPath, paths) => {
-  paths.push(directoryPath || ".");
-}, pushDirectoryFilter = (directoryPath, paths, filters) => {
-  let path = directoryPath || ".";
-  filters.every((filter) => filter(path, !0)) && paths.push(path);
-}, empty$2 = () => {
-};
-function build$6(root, options) {
-  let { includeDirs, filters, relativePaths } = options;
-  return includeDirs ? relativePaths ? filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root) : filters && filters.length ? pushDirectoryFilter : pushDirectory : empty$2;
-}
-var pushFileFilterAndCount = (filename, _paths, counts, filters) => {
-  filters.every((filter) => filter(filename, !1)) && counts.files++;
-}, pushFileFilter = (filename, paths, _counts, filters) => {
-  filters.every((filter) => filter(filename, !1)) && paths.push(filename);
-}, pushFileCount = (_filename, _paths, counts, _filters) => {
-  counts.files++;
-}, pushFile = (filename, paths) => {
-  paths.push(filename);
-}, empty$1 = () => {
-};
-function build$5(options) {
-  let { excludeFiles, filters, onlyCounts } = options;
-  return excludeFiles ? empty$1 : filters && filters.length ? onlyCounts ? pushFileFilterAndCount : pushFileFilter : onlyCounts ? pushFileCount : pushFile;
-}
-var getArray = (paths) => paths, getArrayGroup = () => [""].slice(0, 0);
-function build$4(options) {
-  return options.group ? getArrayGroup : getArray;
-}
-var groupFiles = (groups, directory, files) => {
-  groups.push({
-    directory,
-    files,
-    dir: directory
-  });
-}, empty = () => {
-};
-function build$3(options) {
-  return options.group ? groupFiles : empty;
-}
-var resolveSymlinksAsync = function(path, state, callback$1) {
-  let { queue, fs, options: { suppressErrors } } = state;
-  queue.enqueue(), fs.realpath(path, (error, resolvedPath) => {
-    if (error) return queue.dequeue(suppressErrors ? null : error, state);
-    fs.stat(resolvedPath, (error$1, stat2) => {
-      if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat2.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
-      callback$1(stat2, resolvedPath), queue.dequeue(null, state);
-    });
-  });
-}, resolveSymlinks = function(path, state, callback$1) {
-  let { queue, fs, options: { suppressErrors } } = state;
-  queue.enqueue();
-  try {
-    let resolvedPath = fs.realpathSync(path), stat2 = fs.statSync(resolvedPath);
-    if (stat2.isDirectory() && isRecursive(path, resolvedPath, state)) return;
-    callback$1(stat2, resolvedPath);
-  } catch (e) {
-    if (!suppressErrors) throw e;
-  }
-};
-function build$2(options, isSynchronous) {
-  return !options.resolveSymlinks || options.excludeSymlinks ? null : isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
-}
-function isRecursive(path, resolved, state) {
-  if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname2(path), depth = 1;
-  for (; parent !== state.root && depth < 2; ) {
-    let resolvedPath = state.symlinks.get(parent);
-    !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)) ? depth++ : parent = dirname2(parent);
-  }
-  return state.symlinks.set(path, resolved), depth > 1;
-}
-function isRecursiveUsingRealPaths(resolved, state) {
-  return state.visited.includes(resolved + state.options.pathSeparator);
-}
-var onlyCountsSync = (state) => state.counts, groupsSync = (state) => state.groups, defaultSync = (state) => state.paths, limitFilesSync = (state) => state.paths.slice(0, state.options.maxFiles), onlyCountsAsync = (state, error, callback$1) => (report(error, callback$1, state.counts, state.options.suppressErrors), null), defaultAsync = (state, error, callback$1) => (report(error, callback$1, state.paths, state.options.suppressErrors), null), limitFilesAsync = (state, error, callback$1) => (report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors), null), groupsAsync = (state, error, callback$1) => (report(error, callback$1, state.groups, state.options.suppressErrors), null);
-function report(error, callback$1, output, suppressErrors) {
-  callback$1(error && !suppressErrors ? error : null, output);
-}
-function build$1(options, isSynchronous) {
-  let { onlyCounts, group, maxFiles } = options;
-  return onlyCounts ? isSynchronous ? onlyCountsSync : onlyCountsAsync : group ? isSynchronous ? groupsSync : groupsAsync : maxFiles ? isSynchronous ? limitFilesSync : limitFilesAsync : isSynchronous ? defaultSync : defaultAsync;
-}
-var readdirOpts = { withFileTypes: !0 }, walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  if (state.queue.enqueue(), currentDepth < 0) return state.queue.dequeue(null, state);
-  let { fs } = state;
-  state.visited.push(crawlPath), state.counts.directories++, fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
-    callback$1(entries, directoryPath, currentDepth), state.queue.dequeue(state.options.suppressErrors ? null : error, state);
-  });
-}, walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  let { fs } = state;
-  if (currentDepth < 0) return;
-  state.visited.push(crawlPath), state.counts.directories++;
-  let entries = [];
-  try {
-    entries = fs.readdirSync(crawlPath || ".", readdirOpts);
-  } catch (e) {
-    if (!state.options.suppressErrors) throw e;
-  }
-  callback$1(entries, directoryPath, currentDepth);
-};
-function build(isSynchronous) {
-  return isSynchronous ? walkSync : walkAsync;
-}
-var Queue = class {
-  count = 0;
-  constructor(onQueueEmpty) {
-    this.onQueueEmpty = onQueueEmpty;
-  }
-  enqueue() {
-    return this.count++, this.count;
-  }
-  dequeue(error, output) {
-    this.onQueueEmpty && (--this.count <= 0 || error) && (this.onQueueEmpty(error, output), error && (output.controller.abort(), this.onQueueEmpty = void 0));
-  }
-}, Counter = class {
-  _files = 0;
-  _directories = 0;
-  set files(num) {
-    this._files = num;
-  }
-  get files() {
-    return this._files;
-  }
-  set directories(num) {
-    this._directories = num;
-  }
-  get directories() {
-    return this._directories;
-  }
-  /**
-  * @deprecated use `directories` instead
-  */
-  /* c8 ignore next 3 */
-  get dirs() {
-    return this._directories;
-  }
-}, Aborter = class {
-  aborted = !1;
-  abort() {
-    this.aborted = !0;
-  }
-}, Walker = class {
-  root;
-  isSynchronous;
-  state;
-  joinPath;
-  pushDirectory;
-  pushFile;
-  getArray;
-  groupFiles;
-  resolveSymlink;
-  walkDirectory;
-  callbackInvoker;
-  constructor(root, options, callback$1) {
-    this.isSynchronous = !callback$1, this.callbackInvoker = build$1(options, this.isSynchronous), this.root = normalizePath(root, options), this.state = {
-      root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
-      paths: [""].slice(0, 0),
-      groups: [],
-      counts: new Counter(),
-      options,
-      queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
-      symlinks: /* @__PURE__ */ new Map(),
-      visited: [""].slice(0, 0),
-      controller: new Aborter(),
-      fs: options.fs || nativeFs
-    }, this.joinPath = build$7(this.root, options), this.pushDirectory = build$6(this.root, options), this.pushFile = build$5(options), this.getArray = build$4(options), this.groupFiles = build$3(options), this.resolveSymlink = build$2(options, this.isSynchronous), this.walkDirectory = build(this.isSynchronous);
-  }
-  start() {
-    return this.pushDirectory(this.root, this.state.paths, this.state.options.filters), this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk), this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
-  }
-  walk = (entries, directoryPath, depth) => {
-    let { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
-    if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
-    let files = this.getArray(this.state.paths);
-    for (let i = 0; i < entries.length; ++i) {
-      let entry = entries[i];
-      if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
-        let filename = this.joinPath(entry.name, directoryPath);
-        this.pushFile(filename, files, this.state.counts, filters);
-      } else if (entry.isDirectory()) {
-        let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path)) continue;
-        this.pushDirectory(path, paths, filters), this.walkDirectory(this.state, path, path, depth - 1, this.walk);
-      } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path, this.state, (stat2, resolvedPath) => {
-          if (stat2.isDirectory()) {
-            if (resolvedPath = normalizePath(resolvedPath, this.state.options), exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
-          } else {
-            resolvedPath = useRealPaths ? resolvedPath : path;
-            let filename = basename(resolvedPath), directoryPath$1 = normalizePath(dirname2(resolvedPath), this.state.options);
-            resolvedPath = this.joinPath(filename, directoryPath$1), this.pushFile(resolvedPath, files, this.state.counts, filters);
-          }
-        });
-      }
-    }
-    this.groupFiles(this.state.groups, directoryPath, files);
-  };
-};
-function promise(root, options) {
-  return new Promise((resolve$1, reject) => {
-    callback(root, options, (err, output) => {
-      if (err) return reject(err);
-      resolve$1(output);
-    });
-  });
-}
-function callback(root, options, callback$1) {
-  new Walker(root, options, callback$1).start();
-}
-function sync(root, options) {
-  return new Walker(root, options).start();
-}
-var APIBuilder = class {
-  constructor(root, options) {
-    this.root = root, this.options = options;
-  }
-  withPromise() {
-    return promise(this.root, this.options);
-  }
-  withCallback(cb) {
-    callback(this.root, this.options, cb);
-  }
-  sync() {
-    return sync(this.root, this.options);
-  }
-}, pm = null;
-try {
-  __require.resolve("picomatch"), pm = __require("picomatch");
-} catch {
-}
-var Builder = class {
-  globCache = {};
-  options = {
-    maxDepth: 1 / 0,
-    suppressErrors: !0,
-    pathSeparator: sep,
-    filters: []
-  };
-  globFunction;
-  constructor(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    }, this.globFunction = this.options.globFunction;
-  }
-  group() {
-    return this.options.group = !0, this;
-  }
-  withPathSeparator(separator) {
-    return this.options.pathSeparator = separator, this;
-  }
-  withBasePath() {
-    return this.options.includeBasePath = !0, this;
-  }
-  withRelativePaths() {
-    return this.options.relativePaths = !0, this;
-  }
-  withDirs() {
-    return this.options.includeDirs = !0, this;
-  }
-  withMaxDepth(depth) {
-    return this.options.maxDepth = depth, this;
-  }
-  withMaxFiles(limit) {
-    return this.options.maxFiles = limit, this;
-  }
-  withFullPaths() {
-    return this.options.resolvePaths = !0, this.options.includeBasePath = !0, this;
-  }
-  withErrors() {
-    return this.options.suppressErrors = !1, this;
-  }
-  withSymlinks({ resolvePaths = !0 } = {}) {
-    return this.options.resolveSymlinks = !0, this.options.useRealPaths = resolvePaths, this.withFullPaths();
-  }
-  withAbortSignal(signal) {
-    return this.options.signal = signal, this;
-  }
-  normalize() {
-    return this.options.normalizePath = !0, this;
-  }
-  filter(predicate) {
-    return this.options.filters.push(predicate), this;
-  }
-  onlyDirs() {
-    return this.options.excludeFiles = !0, this.options.includeDirs = !0, this;
-  }
-  exclude(predicate) {
-    return this.options.exclude = predicate, this;
-  }
-  onlyCounts() {
-    return this.options.onlyCounts = !0, this;
-  }
-  crawl(root) {
-    return new APIBuilder(root || ".", this.options);
-  }
-  withGlobFunction(fn) {
-    return this.globFunction = fn, this;
-  }
-  /**
-  * @deprecated Pass options using the constructor instead:
-  * ```ts
-  * new fdir(options).crawl("/path/to/root");
-  * ```
-  * This method will be removed in v7.0
-  */
-  /* c8 ignore next 4 */
-  crawlWithOptions(root, options) {
-    return this.options = {
-      ...this.options,
-      ...options
-    }, new APIBuilder(root || ".", this.options);
-  }
-  glob(...patterns) {
-    return this.globFunction ? this.globWithOptions(patterns) : this.globWithOptions(patterns, { dot: !0 });
-  }
-  globWithOptions(patterns, ...options) {
-    let globFn = this.globFunction || pm;
-    if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
-    var isMatch = this.globCache[patterns.join("\0")];
-    return isMatch || (isMatch = globFn(patterns, ...options), this.globCache[patterns.join("\0")] = isMatch), this.options.filters.push((path) => isMatch(path)), this;
-  }
-};
-
-// ../../node_modules/tinyglobby/dist/index.mjs
-var import_picomatch = __toESM(require_picomatch2(), 1), isReadonlyArray = Array.isArray, BACKSLASHES = /\\/g, DRIVE_RELATIVE_PATH = /^[A-Za-z]:$/, isWin = process.platform === "win32", ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
-function getPartialMatcher(patterns, options = {}) {
-  let patternsCount = patterns.length, patternsParts = Array(patternsCount), matchers = Array(patternsCount), i, j;
-  for (i = 0; i < patternsCount; i++) {
-    let parts = splitPattern(patterns[i]);
-    patternsParts[i] = parts;
-    let partsCount = parts.length, partMatchers = Array(partsCount);
-    for (j = 0; j < partsCount; j++) partMatchers[j] = (0, import_picomatch.default)(parts[j], options);
-    matchers[i] = partMatchers;
-  }
-  return (input) => {
-    let inputParts = input.split("/");
-    if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return !0;
-    for (i = 0; i < patternsCount; i++) {
-      let patternParts = patternsParts[i], matcher = matchers[i], inputPatternCount = inputParts.length, minParts = Math.min(inputPatternCount, patternParts.length);
-      for (j = 0; j < minParts; ) {
-        let part = patternParts[j];
-        if (part.includes("/")) return !0;
-        if (!matcher[j](inputParts[j])) break;
-        if (!options.noglobstar && part === "**") return !0;
-        j++;
-      }
-      if (j === inputPatternCount) return !0;
-    }
-    return !1;
-  };
-}
-var WIN32_ROOT_DIR = /^[A-Z]:\/$/i, isRoot = isWin ? (p) => WIN32_ROOT_DIR.test(p) : (p) => p === "/";
-function buildFormat(cwd, root, absolute) {
-  if (cwd === root || root.startsWith(`${cwd}/`)) {
-    if (absolute) {
-      let start = cwd.length + +!isRoot(cwd);
-      return (p, isDir) => p.slice(start, isDir ? -1 : void 0) || ".";
-    }
-    let prefix = root.slice(cwd.length + 1);
-    return prefix ? (p, isDir) => {
-      if (p === ".") return prefix;
-      let result = `${prefix}/${p}`;
-      return isDir ? result.slice(0, -1) : result;
-    } : (p, isDir) => isDir && p !== "." ? p.slice(0, -1) : p;
-  }
-  return absolute ? (p) => posix.relative(cwd, p) || "." : (p) => posix.relative(cwd, `${root}/${p}`) || ".";
-}
-function buildRelative(cwd, root) {
-  if (root.startsWith(`${cwd}/`)) {
-    let prefix = root.slice(cwd.length + 1);
-    return (p) => `${prefix}/${p}`;
-  }
-  return (p) => {
-    let result = posix.relative(cwd, `${root}/${p}`);
-    return p[p.length - 1] === "/" && result !== "" ? `${result}/` : result || ".";
-  };
-}
-function ensureNonDriveRelativePath(path) {
-  return path.replace(DRIVE_RELATIVE_PATH, (match) => `${match}/`);
-}
-var splitPatternOptions = { parts: !0 };
-function splitPattern(path) {
-  var _result$parts;
-  let result = import_picomatch.default.scan(path, splitPatternOptions);
-  return !((_result$parts = result.parts) === null || _result$parts === void 0) && _result$parts.length ? result.parts : [path];
-}
-var POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g, WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g, escapePosixPath = (path) => path.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapeWin32Path = (path) => path.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&"), escapePath = isWin ? escapeWin32Path : escapePosixPath;
-function isDynamicPattern(pattern, options) {
-  if (options?.caseSensitiveMatch === !1) return !0;
-  let scan = import_picomatch.default.scan(pattern);
-  return scan.isGlob || scan.negated;
-}
-function log(...tasks) {
-  console.log(`[tinyglobby ${(/* @__PURE__ */ new Date()).toLocaleTimeString("es")}]`, ...tasks);
-}
-function ensureStringArray(value) {
-  return typeof value == "string" ? [value] : value ?? [];
-}
-var PARENT_DIRECTORY = /^(\/?\.\.)+/, ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
-function normalizePattern(pattern, opts, props, isIgnore) {
-  var _PARENT_DIRECTORY$exe;
-  let cwd = opts.cwd, result = pattern;
-  pattern[pattern.length - 1] === "/" && (result = pattern.slice(0, -1)), result[result.length - 1] !== "*" && opts.expandDirectories && (result += "/**");
-  let escapedCwd = escapePath(cwd);
-  result = isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")) ? posix.relative(escapedCwd, result) : posix.normalize(result);
-  let parentDir = (_PARENT_DIRECTORY$exe = PARENT_DIRECTORY.exec(result)) === null || _PARENT_DIRECTORY$exe === void 0 ? void 0 : _PARENT_DIRECTORY$exe[0], parts = splitPattern(result);
-  if (parentDir) {
-    let n = (parentDir.length + 1) / 3, i = 0, cwdParts = escapedCwd.split("/");
-    for (; i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]; )
-      result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".", i++;
-    let potentialRoot = posix.join(cwd, parentDir.slice(i * 3));
-    potentialRoot[0] !== "." && props.root.length > potentialRoot.length && (props.root = ensureNonDriveRelativePath(potentialRoot), props.depthOffset = -n + i);
-  }
-  if (!isIgnore && props.depthOffset >= 0) {
-    var _props$commonPath;
-    (_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
-    let newCommonPath = [], length = Math.min(props.commonPath.length, parts.length);
-    for (let i = 0; i < length; i++) {
-      let part = parts[i];
-      if (part === "**" && !parts[i + 1]) {
-        newCommonPath.pop();
-        break;
-      }
-      if (i === parts.length - 1 || part !== props.commonPath[i] || isDynamicPattern(part)) break;
-      newCommonPath.push(part);
-    }
-    props.depthOffset = newCommonPath.length, props.commonPath = newCommonPath, props.root = ensureNonDriveRelativePath(newCommonPath.length > 0 ? posix.join(cwd, ...newCommonPath) : cwd);
-  }
-  return result;
-}
-function processPatterns(options, patterns, props) {
-  let matchPatterns = [], ignorePatterns = [];
-  for (let pattern of options.ignore)
-    pattern && (pattern[0] !== "!" || pattern[1] === "(") && ignorePatterns.push(normalizePattern(pattern, options, props, !0));
-  for (let pattern of patterns)
-    pattern && (pattern[0] !== "!" || pattern[1] === "(" ? matchPatterns.push(normalizePattern(pattern, options, props, !1)) : (pattern[1] !== "!" || pattern[2] === "(") && ignorePatterns.push(normalizePattern(pattern.slice(1), options, props, !0)));
-  return {
-    match: matchPatterns,
-    ignore: ignorePatterns
-  };
-}
-function buildCrawler(options, patterns) {
-  let cwd = options.cwd, props = {
-    root: cwd,
-    depthOffset: 0
-  }, processed = processPatterns(options, patterns, props);
-  options.debug && log("internal processing patterns:", processed);
-  let { absolute, caseSensitiveMatch, debug, dot, followSymbolicLinks, onlyDirectories } = options, root = props.root.replace(BACKSLASHES, ""), matchOptions = {
-    dot,
-    nobrace: options.braceExpansion === !1,
-    nocase: !caseSensitiveMatch,
-    noextglob: options.extglob === !1,
-    noglobstar: options.globstar === !1,
-    posix: !0
-  }, matcher = (0, import_picomatch.default)(processed.match, matchOptions), ignore = (0, import_picomatch.default)(processed.ignore, matchOptions), partialMatcher = getPartialMatcher(processed.match, matchOptions), format = buildFormat(cwd, root, absolute), excludeFormatter = absolute ? format : buildFormat(cwd, root, !0), excludePredicate = (_, p) => {
-    let relativePath = excludeFormatter(p, !0);
-    return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
-  }, maxDepth;
-  options.deep !== void 0 && (maxDepth = Math.round(options.deep - props.depthOffset));
-  let crawler = new Builder({
-    filters: [debug ? (p, isDirectory) => {
-      let path = format(p, isDirectory), matches = matcher(path) && !ignore(path);
-      return matches && log(`matched ${path}`), matches;
-    } : (p, isDirectory) => {
-      let path = format(p, isDirectory);
-      return matcher(path) && !ignore(path);
-    }],
-    exclude: debug ? (_, p) => {
-      let skipped = excludePredicate(_, p);
-      return log(`${skipped ? "skipped" : "crawling"} ${p}`), skipped;
-    } : excludePredicate,
-    fs: options.fs,
-    pathSeparator: "/",
-    relativePaths: !absolute,
-    resolvePaths: absolute,
-    includeBasePath: absolute,
-    resolveSymlinks: followSymbolicLinks,
-    excludeSymlinks: !followSymbolicLinks,
-    excludeFiles: onlyDirectories,
-    includeDirs: onlyDirectories || !options.onlyFiles,
-    maxDepth,
-    signal: options.signal
-  }).crawl(root);
-  return options.debug && log("internal properties:", {
-    ...props,
-    root
-  }), [crawler, cwd !== root && !absolute && buildRelative(cwd, root)];
-}
-function formatPaths(paths, mapper) {
-  if (mapper) for (let i = paths.length - 1; i >= 0; i--) paths[i] = mapper(paths[i]);
-  return paths;
-}
-var defaultOptions = {
-  caseSensitiveMatch: !0,
-  debug: !!process.env.TINYGLOBBY_DEBUG,
-  expandDirectories: !0,
-  followSymbolicLinks: !0,
-  onlyFiles: !0
-};
-function getOptions(options) {
-  let opts = Object.assign({}, options);
-  for (let key in defaultOptions) opts[key] === void 0 && Object.assign(opts, { [key]: defaultOptions[key] });
-  return opts.cwd = (opts.cwd instanceof URL ? fileURLToPath(opts.cwd) : resolve2(opts.cwd || process.cwd())).replace(BACKSLASHES, "/"), opts.ignore = ensureStringArray(opts.ignore), opts.fs && (opts.fs = {
-    readdir: opts.fs.readdir || readdir,
-    readdirSync: opts.fs.readdirSync || readdirSync,
-    realpath: opts.fs.realpath || realpath,
-    realpathSync: opts.fs.realpathSync || realpathSync,
-    stat: opts.fs.stat || stat,
-    statSync: opts.fs.statSync || statSync
-  }), opts.debug && log("globbing with options:", opts), opts;
-}
-function getCrawler(globInput, inputOptions = {}) {
-  var _ref;
-  if (globInput && inputOptions?.patterns) throw new Error("Cannot pass patterns as both an argument and an option");
-  let isModern = isReadonlyArray(globInput) || typeof globInput == "string", patterns = ensureStringArray((_ref = isModern ? globInput : globInput.patterns) !== null && _ref !== void 0 ? _ref : "**/*"), options = getOptions(isModern ? inputOptions : globInput);
-  return patterns.length > 0 ? buildCrawler(options, patterns) : [];
-}
-function globSync(globInput, options) {
-  let [crawler, relative3] = getCrawler(globInput, options);
-  return crawler ? formatPaths(crawler.sync(), relative3) : [];
-}
-
-// src/common/js-package-manager/constants.ts
-var NPM_LOCKFILE = "package-lock.json", PNPM_LOCKFILE = "pnpm-lock.yaml", YARN_LOCKFILE = "yarn.lock", BUN_LOCKFILE = "bun.lock", BUN_LOCKFILE_BINARY = "bun.lockb", LOCK_FILES = [
-  NPM_LOCKFILE,
-  PNPM_LOCKFILE,
-  YARN_LOCKFILE,
-  BUN_LOCKFILE,
-  BUN_LOCKFILE_BINARY
-];
-
-// src/common/utils/paths.ts
-var projectRoot, getProjectRoot = () => {
-  if (projectRoot)
-    return projectRoot;
-  if (process.env.FORKBOOK_PROJECT_ROOT)
-    return process.env.FORKBOOK_PROJECT_ROOT;
-  try {
-    let found = up2(".git") || up2(".svn") || up2(".hg");
-    if (found)
-      return projectRoot = join2(found, ".."), projectRoot;
-  } catch (e) {
-    process.stdout.write(`
-error searching for repository root: ${e}
-`);
-  }
-  try {
-    let found = any(LOCK_FILES);
-    if (found)
-      return projectRoot = join2(found, ".."), projectRoot;
-  } catch (e) {
-    process.stdout.write(`
-error searching for lock file: ${e}
-`);
-  }
-  try {
-    let [basePath, rest] = __dirname.split(`${sep2}node_modules${sep2}`, 2);
-    if (rest && !basePath.includes(`${sep2}npm-cache${sep2}`) && !relative2(basePath, process.cwd()).startsWith(".."))
-      return projectRoot = basePath, projectRoot;
-  } catch (e) {
-    process.stdout.write(`
-error searching for splitDirname: ${e}
-`);
-  }
-  return projectRoot = process.cwd(), projectRoot;
-}, invalidateProjectRootCache = () => {
-  projectRoot = void 0;
-}, findFilesUp = (matchers, baseDir = process.cwd()) => {
-  let matchingFiles = [];
-  for (let directory of up(baseDir, { last: getProjectRoot() }))
-    matchingFiles.push(...globSync(matchers, { cwd: directory, absolute: !0 }));
-  return matchingFiles;
-}, nodePathsToArray = (nodePath) => nodePath.split(process.platform === "win32" ? ";" : ":").filter(Boolean).map((p) => resolve3("./", p)), relativePattern = /^\.{1,2}([/\\]|$)/;
-function normalizeStoryPath(filename) {
-  return relativePattern.test(filename) ? filename : `.${sep2}${filename}`;
-}
-
 export {
-  getService2 as getService,
-  registerService2 as registerService,
-  writeOpenServiceStaticFiles,
-  require_picomatch2 as require_picomatch,
-  NPM_LOCKFILE,
-  PNPM_LOCKFILE,
-  YARN_LOCKFILE,
-  BUN_LOCKFILE,
-  BUN_LOCKFILE_BINARY,
-  getProjectRoot,
-  invalidateProjectRootCache,
-  findFilesUp,
-  nodePathsToArray,
-  normalizeStoryPath
+  require_picomatch2 as require_picomatch
 };