@poe-platform/safe-bash 0.1.799 → 0.1.800

package/dist/safe-bash/command-chunks/chunk-AMO3THU4.js

@@ -0,0 +1,105 @@
+import {
+  flags
+} from "./chunk-UG7SMZFF.js";
+import {
+  expandTabs
+} from "./chunk-6F4XCVON.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/sync.ts
+init_buffer();
+var syncDiffDecoder = new TextDecoder("utf-8", { fatal: false });
+function normalizeSyncDiffLines(text, opts) {
+  const rawLines = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) {
+      rawLines.push(text.slice(start, i + 1));
+      start = i + 1;
+    }
+  }
+  if (start < text.length) rawLines.push(text.slice(start));
+  const out = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    let line = rawLines[i];
+    if (opts.stripTrailingCr && line.endsWith("\r\n")) {
+      line = line.slice(0, -2) + "\n";
+    } else if (opts.stripTrailingCr && line.endsWith("\r")) {
+      line = line.slice(0, -1);
+    }
+    let body = line.endsWith("\n") ? line.slice(0, -1) : line;
+    if (opts.ignoreTabs) body = expandTabs(body);
+    if (opts.whitespace !== "exact") {
+      body = body.replace(/[ \t\v\f\r]+/gu, opts.whitespace === "all" ? "" : " ");
+    }
+    if (opts.ignoreTrailing || opts.whitespace !== "exact") {
+      body = body.replace(/[ \t\v\f\r]+$/u, "");
+    }
+    if (opts.ignoreCase) {
+      body = body.replace(/[A-Z]/gu, (letter) => letter.toLowerCase());
+    }
+    if (opts.ignoreBlank && body === "") continue;
+    const suffix = opts.whitespace !== "exact" || opts.ignoreTrailing || opts.ignoreTabs ? "" : line.endsWith("\n") ? "\n" : "";
+    out.push(body + suffix);
+  }
+  return out;
+}
+function evalSyncDiff(stdinBytes, args, readFile) {
+  let opts;
+  try {
+    opts = flags(args);
+  } catch {
+    return void 0;
+  }
+  const pairFiles = opts.fromFile !== void 0 && opts.toFile === void 0 && opts.files.length === 1 ? [opts.fromFile, opts.files[0]] : opts.toFile !== void 0 && opts.fromFile === void 0 && opts.files.length === 1 ? [opts.files[0], opts.toFile] : opts.fromFile === void 0 && opts.toFile === void 0 && opts.files.length === 2 ? [opts.files[0], opts.files[1]] : void 0;
+  if (!pairFiles || opts.recursive || opts.paginate || opts.format === "side" && !opts.suppressCommon || opts.format === "ifdef") {
+    return void 0;
+  }
+  const left = pairFiles[0];
+  const right = pairFiles[1];
+  if (left === "-" && right === "-") return opts.reportSame ? `Files ${opts.labels[0] ?? left} and ${opts.labels[1] ?? right} are identical
+` : "";
+  const resolveOperand = (op) => {
+    if (op === "-" || op === "/dev/stdin" || op === "/dev/fd/0") return stdinBytes;
+    if (!readFile) return void 0;
+    return readFile(op);
+  };
+  const b1 = resolveOperand(left);
+  const b2 = resolveOperand(right);
+  if (!b1 || !b2) return void 0;
+  let same = false;
+  if (b1.byteLength === b2.byteLength) {
+    same = true;
+    for (let i = 0; i < b1.byteLength; i++) {
+      if (b1[i] !== b2[i]) {
+        same = false;
+        break;
+      }
+    }
+  }
+  if (!same) {
+    if (opts.ignorePatterns.length > 0) return void 0;
+    if (!opts.ignoreCase && !opts.ignoreTrailing && !opts.ignoreBlank && !opts.ignoreTabs && !opts.stripTrailingCr && opts.whitespace === "exact") {
+      return void 0;
+    }
+    for (let i = 0; i < b1.byteLength; i++) if (b1[i] === 0) return void 0;
+    for (let i = 0; i < b2.byteLength; i++) if (b2[i] === 0) return void 0;
+    const t1 = syncDiffDecoder.decode(b1);
+    const t2 = syncDiffDecoder.decode(b2);
+    const l1 = normalizeSyncDiffLines(t1, opts);
+    const l2 = normalizeSyncDiffLines(t2, opts);
+    if (l1.length !== l2.length) return void 0;
+    for (let i = 0; i < l1.length; i++) {
+      if (l1[i] !== l2[i]) return void 0;
+    }
+    same = true;
+  }
+  return opts.reportSame ? `Files ${opts.labels[0] ?? left} and ${opts.labels[1] ?? right} are identical
+` : "";
+}
+
+export {
+  evalSyncDiff
+};

package/dist/safe-bash/command-chunks/chunk-BAGCY35S.js

@@ -0,0 +1,231 @@
+import {
+  safeTarget
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-gnu-paths.ts
+init_buffer();
+import { FsError, basename, dirname, isFsError, resolvePath } from "../../safe-bash-contracts/index.js";
+import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { ToolError, host, inspect } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+function regular(stat, path) {
+  if (stat && stat.type !== "file") throw new ToolError(`patch target is not a regular file: ${path}`);
+  if (stat && (stat.nlink ?? 1) > 1) throw new ToolError(`hard-linked patch targets are unsupported: ${path}`);
+}
+function headerName(path, options) {
+  const safe = safeTarget(path, 0, options.explicit !== void 0);
+  if (safe === void 0) return void 0;
+  if (options.explicit !== void 0) return safe;
+  if (options.strip === void 0) return safe.split("/").at(-1);
+  if (path.split(/\/+/u).filter(Boolean).length <= options.strip) return void 0;
+  return safeTarget(path, options.strip);
+}
+function rejectName(target, options) {
+  return options.reject === "-" ? void 0 : options.reject ?? `${target}.rej`;
+}
+function pruneParents(target, cwd) {
+  const stop = target.startsWith("/") ? "/" : resolvePath(cwd, ".");
+  const parents = [];
+  for (let path = dirname(resolvePath(cwd, target)); path !== stop && path !== "/"; path = dirname(path)) parents.push(path);
+  return parents;
+}
+async function authorizePaths(patches, options, budget, state) {
+  const result = [];
+  for (const patch of patches) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (patch.unlocated) {
+      result.push({ patch, oldName: void 0, newName: void 0, indexName: void 0, candidates: [] });
+      continue;
+    }
+    if (patch.oldPath === "/dev/null" && patch.newPath === "/dev/null") throw new ToolError("both patch filenames are /dev/null");
+    const oldName = headerName(patch.oldPath, options);
+    const newName = headerName(patch.newPath, options);
+    const indexHeader = patch.indexPath === void 0 ? void 0 : headerName(patch.indexPath, options);
+    const indexName = options.posix || patch.format === "normal" || oldName === void 0 && newName === void 0 ? indexHeader : void 0;
+    const candidates = options.explicit === void 0 ? [...new Set([oldName, newName, indexName].filter((name) => name !== void 0))] : [options.explicit];
+    if (!candidates.length) throw new ToolError("strip count removes every patch filename");
+    result.push({ patch, oldName, newName, indexName, candidates, ...options.posix ? { posix: true } : {} });
+  }
+  const order = result.map((_patch, index) => index);
+  if (state?.reverse) order.reverse();
+  budget.step(order.length);
+  const lastChoice = order.findLastIndex((index) => result[index].candidates.length > 1);
+  for (const [position, index] of order.entries()) {
+    const authorized = result[index];
+    if (authorized.patch.unlocated) continue;
+    const selected = await selectTarget(authorized, state?.exists ?? (async (path2) => await candidateStat(path2, budget) !== void 0), budget);
+    const path = resolvePath(budget.context.cwd, selected);
+    if (path === options.input) throw new ToolError(`patch target aliases patch input: ${path}`);
+    regular(await inspect(budget, path), path);
+    result[index] = { ...authorized, selected };
+    if (position < lastChoice) await state?.advance(result[index]);
+  }
+  return result;
+}
+async function backupName(path, budget, options = {}) {
+  const simple = safeTarget(`${path}${options.suffix ?? ".orig"}`, 0, true);
+  if (simple === void 0) throw new ToolError("invalid backup path");
+  if (options.prefix !== void 0 || options.basenamePrefix !== void 0) {
+    const relative = path.startsWith(`${budget.context.cwd}/`) ? path.slice(budget.context.cwd.length + 1) : path;
+    const prefixed = options.prefix !== void 0 ? `${options.prefix}${relative}` : `${dirname(path)}/${options.basenamePrefix ?? ""}${basename(path)}`;
+    const safe = safeTarget(`${prefixed}${options.suffix ?? ".orig"}`, 0, true);
+    if (safe === void 0) throw new ToolError("invalid backup path");
+    return resolvePath(budget.context.cwd, safe);
+  }
+  if (options.versionControl === "simple") return simple;
+  const parent = dirname(path);
+  if (!await inspect(budget, parent)) return options.versionControl === "numbered" ? `${path}.~1~` : simple;
+  const prefix = `${basename(path)}.~`;
+  const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
+  let maximum = "0";
+  for (const entry of entries) {
+    budget.file();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (!entry.name || /[/\0]/u.test(entry.name) || entry.name === "." || entry.name === "..") throw new ToolError("unsafe directory entry in backup directory");
+    if (!entry.name.startsWith(prefix) || !entry.name.endsWith("~")) continue;
+    const version = entry.name.slice(prefix.length, -1);
+    budget.step(version.length);
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (!/^[1-9]\d*$/u.test(version)) continue;
+    if (version.length > maximum.length || version.length === maximum.length && version > maximum) maximum = version;
+  }
+  if (maximum === "0" && options.versionControl !== "numbered") return simple;
+  let position = maximum.length - 1;
+  while (position >= 0 && maximum[position] === "9") position--;
+  const next = position < 0 ? `1${"0".repeat(maximum.length)}` : `${maximum.slice(0, position)}${Number(maximum[position]) + 1}${"0".repeat(maximum.length - position - 1)}`;
+  return `${path}.~${next}~`;
+}
+async function authorizeOutputs(paths, targets, input, budget) {
+  const outputs = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    if (path === void 0) continue;
+    budget.step();
+    if (targets.has(path) || outputs.has(path) || path === input) throw new ToolError(`patch output aliases a target, input, or another output: ${path}`);
+    outputs.add(path);
+    regular(await inspect(budget, path), path);
+  }
+}
+function rank(name) {
+  return [name.split("/").length, byteLength(name.split("/").at(-1)), byteLength(name)];
+}
+async function candidateStat(path, budget) {
+  budget.step();
+  {
+    const c = budget.checkpoint();
+    if (c) await c;
+  }
+  try {
+    return await host(budget.context, () => budget.context.fs.stat(path, { signal: budget.context.signal }));
+  } catch (error) {
+    if (isFsError(error, "ENOENT") || isFsError(error, "ENOTDIR") || isFsError(error, "ELOOP")) return void 0;
+    throw error;
+  }
+}
+async function selectTarget(authorized, exists, budget) {
+  const present = [];
+  for (const candidate of authorized.candidates) {
+    budget.step();
+    if (await exists(resolvePath(budget.context.cwd, candidate))) present.push(candidate);
+  }
+  if (authorized.posix) return present[0] ?? authorized.candidates[0];
+  const candidates = present.length ? present : [...authorized.candidates];
+  const missingParents = /* @__PURE__ */ new Map();
+  if (!present.length) for (const candidate of candidates) {
+    let missing = 0;
+    for (let parent = dirname(resolvePath(budget.context.cwd, candidate)); parent !== "/"; parent = dirname(parent)) {
+      if (await exists(parent)) break;
+      missing++;
+    }
+    missingParents.set(candidate, missing);
+  }
+  candidates.sort((left, right) => {
+    const missing = (missingParents.get(left) ?? 0) - (missingParents.get(right) ?? 0);
+    if (missing) return missing;
+    const leftRank = rank(left);
+    const rightRank = rank(right);
+    for (let index = 0; index < leftRank.length; index++) {
+      const order = leftRank[index] - rightRank[index];
+      if (order) return order;
+    }
+    return 0;
+  });
+  return candidates[0];
+}
+async function ensureParents(path, budget) {
+  const missing = [];
+  for (let parent = dirname(path); ; parent = dirname(parent)) {
+    const stat = await inspect(budget, parent);
+    if (stat) {
+      if (stat.type !== "directory") throw new ToolError(`not a directory: ${parent}`);
+      break;
+    }
+    if (parent === "/") throw new ToolError("filesystem root does not exist");
+    missing.push(parent);
+  }
+  for (const parent of missing.reverse()) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    await inspect(budget, parent);
+    await host(budget.context, () => budget.context.fs.mkdir(parent, { signal: budget.context.signal }));
+  }
+}
+async function pruneDirectories(parents, budget) {
+  for (const parent of [...parents].sort((left, right) => right.split("/").length - left.split("/").length)) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const stat = await inspect(budget, parent);
+    budget.context.signal.throwIfAborted();
+    if (!stat) continue;
+    if (stat.type !== "directory") throw new ToolError(`pruning path changed type: ${parent}`);
+    try {
+      const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
+      budget.step(entries.length);
+      if (entries.length) continue;
+      const rmdir = budget.context.fs.rmdir;
+      if (!rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path: parent });
+      try {
+        await host(budget.context, () => rmdir.call(budget.context.fs, parent, { signal: budget.context.signal }));
+      } catch (error) {
+        budget.context.signal.throwIfAborted();
+        if (!isFsError(error, "ENOTEMPTY")) throw error;
+      }
+    } catch (error) {
+      budget.context.signal.throwIfAborted();
+      if (isFsError(error, "ENOENT")) continue;
+      if (isFsError(error) || error instanceof ToolError) throw error;
+      throw new ToolError(`cannot prune directory ${parent}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
+    }
+  }
+}
+
+export {
+  regular,
+  rejectName,
+  pruneParents,
+  authorizePaths,
+  backupName,
+  authorizeOutputs,
+  candidateStat,
+  selectTarget,
+  ensureParents,
+  pruneDirectories
+};

package/dist/safe-bash/command-chunks/chunk-BAXU7B5Z.js

@@ -0,0 +1,101 @@
+import {
+  PandocError
+} from "./chunk-7OKDCM5U.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-pandoc/dist/chunks/chunk-YI4UJTYX.js
+init_buffer();
+function imageLength(value, natural, context, format) {
+  if (value === void 0) return natural;
+  const units = { in: 914400, pt: 12700, cm: 36e4, mm: 36e3, px: 9525 };
+  const unit = Object.keys(units).find((unit2) => value.endsWith(unit2));
+  const number = unit ? Number(value.slice(0, -unit.length)) : NaN;
+  const result = unit ? Math.round(number * units[unit]) : NaN;
+  if (!Number.isSafeInteger(result) || result <= 0)
+    throw new PandocError("E_OPTION", context.operation ?? "write", "Image dimensions require positive in, pt, cm, mm or px values", format);
+  return result;
+}
+
+export {
+  imageLength
+};
+/*!
+MIT License
+
+Copyright © 2017-2019 Benoit Giannangeli
+Copyright © 2017-2025 Daurnimator
+Copyright © 1994–2017 Lua.org, PUC-Rio.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+/*!
+Copyright (c) 2007-present, Alexandru Mărășteanu <hello@alexei.ro>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this software nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+/*!
+	Copyright (c) 2009-2019 Frank Bennett
+
+	This program is free software: you can redistribute it and/or
+	modify it under EITHER
+
+      * the terms of the Common Public Attribution License (CPAL) as
+	    published by the Open Source Initiative, either version 1 of
+	    the CPAL, or (at your option) any later version; OR
+
+      * the terms of the GNU Affero General Public License (AGPL)
+        as published by the Free Software Foundation, either version
+        3 of the AGPL, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Affero General Public License for more details.
+
+	You should have received copies of the Common Public Attribution
+    License and of the GNU Affero General Public License along with
+    this program.  If not, see <https://opensource.org/licenses/> or
+    <http://www.gnu.org/licenses/> respectively.
+
+*/

package/dist/safe-bash/command-chunks/{chunk-KMCZ6P4O.js → chunk-BKCNF5U3.js}

@@ -1,12 +1,15 @@
+import {
+  extendedPattern
+} from "./chunk-GI4CJED2.js";
 import {
   describe
-} from "./chunk-YZ5SVZFD.js";
+} from "./chunk-UMDIOL3O.js";
 import {
   JqError,
   JqLimitError,
   object,
   put
-} from "./chunk-VVI4Z73I.js";
+} from "./chunk-QP4R6GLA.js";
 import {
   utf8ByteLength
 } from "./chunk-PDKXAR4Y.js";
@@ -18,7 +21,7 @@ import {
 init_buffer();
 import { Pattern } from "../../safe-bash-regex-engine/text/regex.js";
 import { ProgramError } from "../../safe-bash-regex-engine/text/budget.js";
-async function* substituteRegex(input, source, flags, replacement, budget) {
+async function* substituteRegex(input, source, flags, replacement, budget, global = true) {
   if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
   if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
   if (typeof flags !== "string" || [...flags].some((flag) => !"gimns".includes(flag))) throw new JqError(`${typeof flags === "string" ? flags + "g" : describe(flags, budget)} is not a valid modifier string`);
@@ -58,6 +61,7 @@ async function* substituteRegex(input, source, flags, replacement, budget) {
         results = next;
         copied = match.end;
       }
+      if (!global && !flags.includes("g")) break;
       search = match.end > match.start ? match.end : match.end + ((input.codePointAt(match.end) ?? 0) > 65535 ? 2 : 1);
     }
     for (const prefix of results) {
@@ -76,10 +80,11 @@ function regexError(error) {
   const message = error.message === "unterminated bracket expression" ? "premature end of char-class" : error.message === "unmatched '(' in regular expression" ? "end pattern with unmatched parenthesis" : error.message === "quantifier without an expression" ? "target of repeat operator is not specified" : error.message === "reversed character range" ? "empty range in char class" : error.message;
   return new JqError(`Regex failure: ${message}`);
 }
-async function* scanRegex(input, source, budget) {
+async function* scanRegex(input, source, budget, modifiers = null) {
+  const flags = regexFlags(modifiers, budget);
   if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
   if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
-  if (source === "") {
+  if (source === "" && !flags.includes("n")) {
     const boundaries = utf8ByteLength(input) + 1;
     for (let index = 0; index < boundaries; index++) {
       {
@@ -93,7 +98,7 @@ async function* scanRegex(input, source, budget) {
   const work = { step: (count = 1) => budget.step(count), checkpoint: () => budget.tick(0), maxBufferBytes: budget.limits.maxValueBytes };
   try {
     budget.step(source.length);
-    const pattern = new Pattern(source, true, false, "jq");
+    const pattern = new Pattern(flags.includes("x") ? await extendedPattern(source, budget) : source, true, flags.includes("i"), "jq", flags.includes("p") ? flags + "m" : flags);
     let search = 0;
     while (search <= input.length) {
       const match = await pattern.find(input, work, search);
@@ -108,9 +113,65 @@ async function* scanRegex(input, source, budget) {
     throw regexError(error);
   }
 }
+function regexFlags(modifiers, budget) {
+  if (modifiers !== null && typeof modifiers !== "string") throw new JqError(`${describe(modifiers, budget)} is not a string`);
+  const flags = modifiers ?? "";
+  if ([...flags].some((flag) => !"gimnpsx".includes(flag))) throw new JqError(`${flags} is not a valid modifier string`);
+  return flags;
+}
+async function* matchRegex(input, source, modifiers, budget, test) {
+  if (typeof input !== "string") throw new JqError(`${describe(input, budget)} cannot be matched, as it is not a string`);
+  if (typeof source !== "string") throw new JqError(`${describe(source, budget)} is not a string`);
+  const flags = regexFlags(modifiers, budget);
+  const work = { step: (count = 1) => budget.step(count), checkpoint: () => budget.tick(0), maxBufferBytes: budget.limits.maxValueBytes };
+  try {
+    budget.step(source.length + input.length);
+    const pattern = new Pattern(flags.includes("x") ? await extendedPattern(source, budget) : source, true, flags.includes("i"), "jq", flags.includes("p") ? flags + "m" : flags);
+    let search = 0;
+    while (search <= input.length) {
+      const match = await pattern.find(input, work, search);
+      if (!match) {
+        if (test) yield false;
+        return;
+      }
+      if (test) {
+        yield true;
+        return;
+      }
+      const position = (start, end) => {
+        budget.step(end + start);
+        return { offset: [...input.slice(0, start)].length, length: [...input.slice(start, end)].length, string: input.slice(start, end) };
+      };
+      const names = new Map([...pattern.groupNames].map(([name, index]) => [index, name]));
+      const captures = [];
+      budget.collection(pattern.groupCount);
+      for (let index = 1; index <= pattern.groupCount; index++) {
+        const start = match.captureOffsets?.[index * 2];
+        const end = match.captureOffsets?.[index * 2 + 1];
+        captures.push({ ...start === void 0 || end === void 0 ? { offset: -1, length: 0, string: null } : position(start, end), name: names.get(index) ?? null });
+      }
+      const result = { ...position(match.start, match.end), captures };
+      budget.value(result);
+      yield result;
+      if (!flags.includes("g")) return;
+      if (source === "" && match.end < input.length) {
+        const character = String.fromCodePoint(input.codePointAt(match.end));
+        for (let repeat = 1; repeat < utf8ByteLength(character); repeat++) {
+          await budget.tick();
+          yield { offset: result.offset + 1, length: 0, string: "", captures: [] };
+        }
+      }
+      search = match.end > match.start ? match.end : match.end + ((input.codePointAt(match.end) ?? 0) > 65535 ? 2 : 1);
+    }
+  } catch (error) {
+    throw regexError(error);
+  }
+}
 
 export {
   substituteRegex,
   regexError,
-  scanRegex
+  scanRegex,
+  regexFlags,
+  matchRegex
 };