@poe-platform/safe-js 0.1.463 → 0.1.465

package/dist/safe-js/chunks/{chunk-KCQ7OJWN.js → chunk-5VDQL2IH.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-NYT6Z4RI.js";
+} from "./chunk-BTSRG46T.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-KCQ7OJWN.js.map
+//# sourceMappingURL=chunk-5VDQL2IH.js.map

package/dist/safe-js/chunks/{chunk-NYT6Z4RI.js → chunk-BTSRG46T.js}

@@ -6288,11 +6288,11 @@ function assertBareImportSpecifier(specifier) {
   }
 }
 function hasInvalidImportPathDots(value) {
-  const segments = value.split(".");
-  if (segments.some((segment) => segment.length === 0)) {
+  const segments2 = value.split(".");
+  if (segments2.some((segment) => segment.length === 0)) {
     return true;
   }
-  return segments.length > 1 && ["js", "mjs", "cjs", "ts", "mts", "cts", "json"].includes(segments.at(-1) ?? "");
+  return segments2.length > 1 && ["js", "mjs", "cjs", "ts", "mts", "cts", "json"].includes(segments2.at(-1) ?? "");
 }
 function hasProtocolPrefix(value) {
   const colonIndex = value.indexOf(":");
@@ -9036,6 +9036,48 @@ function nextStringIterator(value, budget) {
   return { value: entry, done: false };
 }
 
+// packages/safe-js/src/interp/intl-segmenter.ts
+var NativeSegmenter = Intl.Segmenter;
+var nativeSegment = NativeSegmenter.prototype.segment;
+var nativeResolvedOptions = NativeSegmenter.prototype.resolvedOptions;
+var nativeContaining = Object.getPrototypeOf(new NativeSegmenter("en").segment("")).containing;
+var segmenters = /* @__PURE__ */ new WeakMap();
+var segments = /* @__PURE__ */ new WeakMap();
+function createSandboxSegmenter(locales2, options) {
+  const native = new NativeSegmenter(locales2, options);
+  const value = /* @__PURE__ */ Object.create(null);
+  segmenters.set(value, { native, options: Reflect.apply(nativeResolvedOptions, native, []) });
+  return value;
+}
+function isSandboxSegmenter(value) {
+  return typeof value === "object" && value !== null && segmenters.has(value);
+}
+function segmenterState(value) {
+  if (!isSandboxSegmenter(value)) throw new TypeError("Intl.Segmenter requires a Segmenter receiver.");
+  return segmenters.get(value);
+}
+function createSandboxSegments(state) {
+  const native = Reflect.apply(nativeSegment, segmenterState(state.segmenter).native, [state.input]);
+  const value = /* @__PURE__ */ Object.create(null);
+  segments.set(value, { ...state, native });
+  return value;
+}
+function isSandboxSegments(value) {
+  return typeof value === "object" && value !== null && segments.has(value);
+}
+function segmentState(value, iterator) {
+  if (!isSandboxSegments(value) || iterator !== void 0 && segments.get(value).index !== void 0 !== iterator)
+    throw new TypeError(iterator ? "Segment iterator requires a segment iterator receiver." : "Segments method requires a Segments receiver.");
+  return segments.get(value);
+}
+function containingSegment(value, index, iterator, budget) {
+  const state = segmentState(value, iterator);
+  budget.visitNode(state.input.length + 1);
+  const result = Reflect.apply(nativeContaining, state.native, [index]);
+  if (iterator && result !== void 0) state.index = result.index + result.segment.length;
+  return result === void 0 ? void 0 : { ...result };
+}
+
 // packages/safe-js/src/interp/iterator-wrapper.ts
 var iteratorWrapperStates = /* @__PURE__ */ new WeakMap();
 
@@ -19808,7 +19850,7 @@ import { types as types7 } from "node:util";
 
 // packages/safe-js/src/interp/intl-collator.ts
 var NativeCollator = Intl.Collator;
-var nativeResolvedOptions = NativeCollator.prototype.resolvedOptions;
+var nativeResolvedOptions2 = NativeCollator.prototype.resolvedOptions;
 var nativeCompare = Object.getOwnPropertyDescriptor(NativeCollator.prototype, "compare").get;
 var states5 = /* @__PURE__ */ new WeakMap();
 var optionTypes = [
@@ -19847,7 +19889,7 @@ async function readCollatorOptions(input, budget, context, invalid) {
 function createSandboxCollator(locales2, options) {
   const native = new NativeCollator(locales2, options);
   const value = /* @__PURE__ */ Object.create(null);
-  states5.set(value, { native, options: Reflect.apply(nativeResolvedOptions, native, []) });
+  states5.set(value, { native, options: Reflect.apply(nativeResolvedOptions2, native, []) });
   return value;
 }
 function isSandboxCollator(value) {
@@ -28652,7 +28694,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
   }
   const updated = Object.values(base).filter((value) => value !== void 0).join("-") + canonical.slice(native.baseName.length);
   const extension = unicodeKeywords(updated);
-  const optionTypes6 = [
+  const optionTypes7 = [
     ["calendar", "ca", "unicodeType"],
     ["collation", "co", "unicodeType"],
     ["firstDayOfWeek", "fw", "unicodeType"],
@@ -28661,7 +28703,7 @@ async function buildLocaleTag(input, optionsInput, budget, context) {
     ["numeric", "kn", "boolean"],
     ["numberingSystem", "nu", "unicodeType"]
   ];
-  for (const [key, extensionKey, type] of optionTypes6) {
+  for (const [key, extensionKey, type] of optionTypes7) {
     let value = await readIntlProperty(options, key, budget, context);
     if (value === void 0) continue;
     if (key === "firstDayOfWeek") {
@@ -29175,6 +29217,17 @@ function captureGuestHeapNode(value, encode) {
   }
   if (isSandboxLocale(value)) return { kind: "guest-locale", tag: localeTag(value), state: captureObjectState(value, encode) };
   if (isSandboxListFormat(value)) return { kind: "guest-listformat", options: { ...listFormatState(value).options }, state: captureObjectState(value, encode) };
+  if (isSandboxSegmenter(value)) return { kind: "guest-segmenter", options: { ...segmenterState(value).options }, state: captureObjectState(value, encode) };
+  if (isSandboxSegments(value)) {
+    const state2 = segmentState(value);
+    return {
+      kind: "guest-segments",
+      segmenter: encode(state2.segmenter),
+      input: state2.input,
+      ...state2.index === void 0 ? {} : { index: state2.index },
+      state: captureObjectState(value, encode)
+    };
+  }
   if (isSandboxRelativeTimeFormat(value)) return { kind: "guest-relativetimeformat", options: { ...relativeTimeFormatState(value).options }, state: captureObjectState(value, encode) };
   if (isSandboxDisplayNames(value)) return { kind: "guest-displaynames", options: { ...displayNamesState(value).options }, state: captureObjectState(value, encode) };
   if (isSandboxPluralRules(value)) {
@@ -34238,6 +34291,154 @@ function createPluralRulesConstructor(budget) {
   return constructor;
 }
 
+// packages/safe-js/src/interp/globals/intl-segmenter.ts
+var supportedLocalesOf9 = Intl.Segmenter.supportedLocalesOf;
+var optionTypes6 = [
+  ["localeMatcher", ["lookup", "best fit"]],
+  ["granularity", ["grapheme", "word", "sentence"]]
+];
+function createSegmenterConstructor(budget) {
+  const prototype = createIntrinsicObject();
+  const segmentsPrototype = createIntrinsicObject();
+  const iteratorPrototype = createIntrinsicObject();
+  setSandboxPrototype(iteratorPrototype, resolveIntrinsicIdentity(budget, '["%IteratorPrototype%"]'));
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "Segmenter",
+    length: 0,
+    call: () => {
+      throw new TypeError("Constructor Segmenter requires 'new'.");
+    },
+    construct: async ([input, options], context) => {
+      const target = context?.newTarget;
+      const selected = target === void 0 || target === constructor ? prototype : context?.getProperty !== void 0 ? await context.getProperty(target, "prototype") : await readPropertyDescriptor(getSandboxPropertyDescriptor(target, "prototype", budget) ?? { value: void 0 }, target, context);
+      let locales2 = [];
+      const converted = /* @__PURE__ */ Object.create(null);
+      const release = retainValues(budget, () => [selected, locales2, converted]);
+      try {
+        locales2 = await canonicalizeGuestLocales(input, budget, context);
+        const source = intlOptionsObject(options, budget);
+        for (const [key, type] of optionTypes6) {
+          const raw = await readIntlProperty(source, key, budget, context);
+          if (raw !== void 0) converted[key] = await convertIntlOption(raw, key, type, budget, context);
+        }
+        const value = createSandboxSegmenter(locales2, converted);
+        setSandboxPrototype(value, typeof selected === "object" && selected !== null ? selected : prototype, budget);
+        return allocateProducedSandboxValue(value, budget);
+      } finally {
+        release();
+      }
+    }
+  });
+  const properties = materializeFunctionProperties(constructor);
+  Object.defineProperty(properties, "prototype", { value: prototype, writable: false, configurable: false });
+  Object.defineProperty(properties, "supportedLocalesOf", { value: createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "supportedLocalesOf",
+    length: 1,
+    call: async ([input, options], context) => {
+      const locales2 = await canonicalizeGuestLocales(input, budget, context);
+      const release = retainValues(budget, () => [locales2]);
+      try {
+        const source = intlOptionsObject(options, budget);
+        const raw = await readIntlProperty(source, "localeMatcher", budget, context);
+        const matcher = raw === void 0 ? void 0 : await convertIntlOption(raw, "localeMatcher", ["lookup", "best fit"], budget, context);
+        return allocateProducedSandboxValue(supportedLocalesOf9(locales2, { localeMatcher: matcher }), budget);
+      } finally {
+        release();
+      }
+    }
+  }), writable: true, configurable: true });
+  Object.defineProperties(prototype, {
+    constructor: { value: constructor, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Intl.Segmenter", configurable: true },
+    resolvedOptions: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "resolvedOptions",
+      length: 0,
+      call: (_args, context) => allocateProducedSandboxValue({ ...segmenterState(context?.thisValue).options }, budget)
+    }), writable: true, configurable: true },
+    segment: { value: createSandboxClosure({
+      guest: true,
+      sandbox: true,
+      name: "segment",
+      length: 1,
+      call: async ([input], context) => {
+        const receiver = context?.thisValue;
+        segmenterState(receiver);
+        const release = retainValues(budget, () => [receiver, input]);
+        try {
+          const text = await sandboxString(input, budget, context);
+          budget.visitNode(text.length);
+          const value = createSandboxSegments({ segmenter: receiver, input: text });
+          setSandboxPrototype(value, segmentsPrototype, budget);
+          return allocateProducedSandboxValue(value, budget);
+        } finally {
+          release();
+        }
+      }
+    }), writable: true, configurable: true }
+  });
+  const containing = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "containing",
+    length: 1,
+    call: async ([input], context) => {
+      const receiver = context?.thisValue;
+      segmentState(receiver, false);
+      const release = retainValues(budget, () => [receiver, input]);
+      try {
+        const number = await sandboxNumber(input, budget, context);
+        const index = Number.isNaN(number) ? 0 : Math.trunc(number);
+        return allocateProducedSandboxValue(containingSegment(receiver, index, false, budget), budget);
+      } finally {
+        release();
+      }
+    }
+  });
+  const iterate = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "[Symbol.iterator]",
+    length: 0,
+    call: (_args, context) => {
+      const state = segmentState(context?.thisValue, false);
+      budget.visitNode(state.input.length);
+      const value = createSandboxSegments({ segmenter: state.segmenter, input: state.input, index: 0 });
+      setSandboxPrototype(value, iteratorPrototype, budget);
+      return allocateProducedSandboxValue(value, budget);
+    }
+  });
+  const next = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "next",
+    length: 0,
+    call: (_args, context) => {
+      const receiver = context?.thisValue;
+      const state = segmentState(receiver, true);
+      const value = containingSegment(receiver, state.index, true, budget);
+      return allocateProducedSandboxValue({ value, done: value === void 0 }, budget);
+    }
+  });
+  Object.defineProperties(segmentsPrototype, {
+    containing: { value: containing, writable: true, configurable: true },
+    [Symbol.iterator]: { value: iterate, writable: true, configurable: true }
+  });
+  Object.defineProperties(iteratorPrototype, {
+    next: { value: next, writable: true, configurable: true },
+    [Symbol.toStringTag]: { value: "Segmenter String Iterator", configurable: true }
+  });
+  registerBuiltinIdentities(budget, { "%IntlSegmentsPrototype%": segmentsPrototype, "%IntlSegmentIteratorPrototype%": iteratorPrototype });
+  for (const closure of [containing, iterate, next]) registerIntrinsicFunction(budget, closure);
+  for (const value of [segmentsPrototype, iteratorPrototype]) registerIntrinsicObject(budget, value);
+  return constructor;
+}
+
 // packages/safe-js/src/interp/globals/intl.ts
 var supportedValuesOf = Intl.supportedValuesOf;
 function createIntlGlobal(budget, now) {
@@ -34258,6 +34459,7 @@ function createIntlGlobal(budget, now) {
   const displayNames = createDisplayNamesConstructor(budget);
   const dateTimeFormat = createDateTimeFormatConstructor(budget, now);
   const pluralRules = createPluralRulesConstructor(budget);
+  const segmenter = createSegmenterConstructor(budget);
   Object.defineProperty(intl, "Locale", { value: locale, writable: true, configurable: true });
   Object.defineProperty(intl, "Collator", { value: collator, writable: true, configurable: true });
   Object.defineProperty(intl, "NumberFormat", { value: numberFormat, writable: true, configurable: true });
@@ -34266,13 +34468,14 @@ function createIntlGlobal(budget, now) {
   Object.defineProperty(intl, "DisplayNames", { value: displayNames, writable: true, configurable: true });
   Object.defineProperty(intl, "DateTimeFormat", { value: dateTimeFormat, writable: true, configurable: true });
   Object.defineProperty(intl, "PluralRules", { value: pluralRules, writable: true, configurable: true });
+  Object.defineProperty(intl, "Segmenter", { value: segmenter, writable: true, configurable: true });
   for (const [name, call] of Object.entries(methods3)) {
     const closure = createSandboxClosure({ guest: true, sandbox: true, name, length: 1, call });
     Object.defineProperty(intl, name, { value: closure, writable: true, configurable: true });
   }
   Object.defineProperty(intl, Symbol.toStringTag, { value: "Intl", configurable: true });
   registerBuiltinIdentities(budget, { Intl: intl });
-  for (const constructor of [locale, collator, numberFormat, listFormat, relativeTimeFormat, displayNames, dateTimeFormat, pluralRules]) {
+  for (const constructor of [locale, collator, numberFormat, listFormat, relativeTimeFormat, displayNames, dateTimeFormat, pluralRules, segmenter]) {
     const prototype = constructor.properties.prototype;
     for (const owner of [prototype, constructor.properties])
       for (const descriptor of Object.values(Object.getOwnPropertyDescriptors(owner)))
@@ -34390,7 +34593,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["module-function", "async-generator-driver", "async-generator-handler", "async-function-driver", "async-function-handler", "thenable-state", "thenable-resolver", "construction-environment", "capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-locale", "guest-listformat", "guest-pluralrules", "guest-displaynames", "guest-relativetimeformat", "guest-datetimeformat", "guest-numberformat", "guest-collator", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "async-disposable-stack", "async-cleanup", "async-cleanup-handler", "disposable-stack", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["guest-segmenter", "guest-segments", "module-function", "async-generator-driver", "async-generator-handler", "async-function-driver", "async-function-handler", "thenable-state", "thenable-resolver", "construction-environment", "capability-executor", "promise-aggregate", "aggregate-entry", "aggregate-handler", "intrinsic", "bound-function", "promise-resolver", "pending-promise", "promise-reaction", "promise-adoption", "adoption-resolver", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-locale", "guest-listformat", "guest-pluralrules", "guest-displaynames", "guest-relativetimeformat", "guest-datetimeformat", "guest-numberformat", "guest-collator", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "async-disposable-stack", "async-cleanup", "async-cleanup-handler", "disposable-stack", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record2(value);
     fields(ref, ["kind", "id"]);
@@ -34698,6 +34901,28 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     const restored = listFormatState(createSandboxListFormat(options.locale, options)).options;
     if (names.some((key) => options[key] !== restored[key])) throw new TypeError("Invalid resolved ListFormat options.");
     state(node.state);
+  } else if (node.kind === "guest-segmenter") {
+    fields(node, ["kind", "options", "state"]);
+    const options = record2(node.options);
+    fields(options, ["locale", "granularity"]);
+    if (typeof options.locale !== "string" || typeof options.granularity !== "string") throw new TypeError("Invalid Segmenter options.");
+    const restored = segmenterState(createSandboxSegmenter(options.locale, options)).options;
+    if (options.locale !== restored.locale || options.granularity !== restored.granularity) throw new TypeError("Invalid resolved Segmenter options.");
+    state(node.state);
+  } else if (node.kind === "guest-segments") {
+    fields(node, ["kind", "segmenter", "input", "state"], ["index"]);
+    const segmenter = reference(node.segmenter, ["guest-segmenter"]);
+    if (typeof node.input !== "string") throw new TypeError("Invalid segments input.");
+    if (node.index !== void 0) {
+      if (!Number.isSafeInteger(node.index) || node.index < 0 || node.index > node.input.length)
+        throw new TypeError("Invalid segment iterator index.");
+      const options = record2(segmenter.options);
+      const owner = createSandboxSegmenter(options.locale, options);
+      const value = createSandboxSegments({ segmenter: owner, input: node.input });
+      if (node.index < node.input.length && segmentState(value).native.containing(node.index)?.index !== node.index)
+        throw new TypeError("Invalid segment iterator boundary.");
+    }
+    state(node.state);
   } else if (node.kind === "guest-pluralrules") {
     fields(node, ["kind", "options", "state"]);
     const options = record2(node.options);
@@ -38283,7 +38508,7 @@ var structuredCloneErrorNames = ["Error", "EvalError", "RangeError", "ReferenceE
 function* cloneStructuredGraph(value, state, budget, depth = 0) {
   assertSandboxDataDepth(depth);
   budget.visitNode();
-  if (typeof value === "symbol" || isSandboxModuleNamespace(value) || isSandboxClosure(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxArrayIterator(value) || isSandboxStringIterator(value) || isSandboxArguments(value))
+  if (typeof value === "symbol" || isSandboxModuleNamespace(value) || isSandboxClosure(value) || isSandboxPromise(value) || isSandboxGenerator(value) || isSandboxCollectionIterator(value) || isSandboxRegExpIterator(value) || isSandboxArrayIterator(value) || isSandboxStringIterator(value) || isSandboxArguments(value) || isSandboxSegmenter(value) || isSandboxSegments(value) || isSandboxLocale(value) || isSandboxCollator(value) || isSandboxDateTimeFormat(value) || isSandboxDisplayNames(value) || isSandboxListFormat(value) || isSandboxNumberFormat(value) || isSandboxPluralRules(value) || isSandboxRelativeTimeFormat(value))
     throw new DOMException("Value cannot be structured cloned.", "DataCloneError");
   if (typeof value !== "object" || value === null) return allocateProducedSandboxValue(value, budget);
   if (iteratorHelperStates.has(value) || iteratorWrapperStates.has(value))
@@ -38558,6 +38783,12 @@ function measureSandboxData(values, options = {}) {
     }
     if (isSandboxArrayIterator(value)) visit(arrayIteratorState(value).source, depth + 1);
     if (isSandboxStringIterator(value)) visit(stringIteratorState(value).input, depth + 1);
+    if (isSandboxSegmenter(value)) visit(segmenterState(value).options, depth + 1);
+    if (isSandboxSegments(value)) {
+      const state = segmentState(value);
+      visit(state.segmenter, depth + 1);
+      visit(state.input, depth + 1);
+    }
     if (isSandboxRegExpIterator(value)) {
       const state = regexpIteratorState(value);
       visit(state.matcher, depth + 1);
@@ -56481,4 +56712,4 @@ The above copyright notice and this permission notice shall be included in all c
 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.
 
 */
-//# sourceMappingURL=chunk-NYT6Z4RI.js.map
+//# sourceMappingURL=chunk-BTSRG46T.js.map