@nocobase/plugin-flow-engine 2.0.0-alpha.2

package/dist/node_modules/ses/src/reporting-types.d.ts

@@ -0,0 +1,13 @@
+/* eslint-disable no-restricted-globals */
+
+export type Reporter = {
+  warn: (...message: Array<any>) => void;
+  error: (...message: Array<string>) => void;
+};
+
+export type GroupReporter = Reporter & {
+  groupCollapsed?: (label: string) => void;
+  groupEnd?: () => void;
+};
+
+// Console implements GroupReporter

package/dist/node_modules/ses/src/reporting.js

@@ -0,0 +1,105 @@
+import { functionBind, globalThis } from './commons.js';
+import { assert } from './error/assert.js';
+
+/**
+ * @import {Reporter, GroupReporter} from './reporting-types.js'
+ */
+
+/**
+ * Creates a suitable reporter for internal errors and warnings out of the
+ * Node.js console.error to ensure all messages to go stderr, including the
+ * group label.
+ * Accounts for the extra space introduced by console.error as a delimiter
+ * between the indent and subsequent arguments.
+ *
+ * @param {(...message: Array<any>) => void} print
+ */
+const makeReportPrinter = print => {
+  let indent = false;
+  /** @param {Array<any>} args */
+  const printIndent = (...args) => {
+    if (indent) {
+      print(' ', ...args);
+    } else {
+      print(...args);
+    }
+  };
+  return /** @type {GroupReporter} */ ({
+    warn(...args) {
+      printIndent(...args);
+    },
+    error(...args) {
+      printIndent(...args);
+    },
+    groupCollapsed(...args) {
+      assert(!indent);
+      print(...args);
+      indent = true;
+    },
+    groupEnd() {
+      indent = false;
+    },
+  });
+};
+
+const mute = () => {};
+
+/**
+ * @param {"platform" | "console" | "none"} reporting
+ */
+export const chooseReporter = reporting => {
+  if (reporting === 'none') {
+    return makeReportPrinter(mute);
+  }
+  if (
+    reporting === 'console' ||
+    globalThis.window === globalThis ||
+    globalThis.importScripts !== undefined
+  ) {
+    return console;
+  }
+  if (globalThis.console !== undefined) {
+    // On Node.js, we send all feedback to stderr, regardless of purported level.
+    const console = globalThis.console;
+    const error = functionBind(console.error, console);
+    return makeReportPrinter(error);
+  }
+  if (globalThis.print !== undefined) {
+    return makeReportPrinter(globalThis.print);
+  }
+  return makeReportPrinter(mute);
+};
+
+/**
+ * @param {string} groupLabel
+ * @param {GroupReporter} console
+ * @param {(internalConsole: Reporter) => void} callback
+ */
+export const reportInGroup = (groupLabel, console, callback) => {
+  const { warn, error, groupCollapsed, groupEnd } = console;
+  const grouping = groupCollapsed && groupEnd;
+  let groupStarted = false;
+  try {
+    return callback({
+      warn(...args) {
+        if (grouping && !groupStarted) {
+          groupCollapsed(groupLabel);
+          groupStarted = true;
+        }
+        warn(...args);
+      },
+      error(...args) {
+        if (grouping && !groupStarted) {
+          groupCollapsed(groupLabel);
+          groupStarted = true;
+        }
+        error(...args);
+      },
+    });
+  } finally {
+    if (grouping && groupStarted) {
+      groupEnd();
+      groupStarted = false;
+    }
+  }
+};

package/dist/node_modules/ses/src/scope-constants.js

@@ -0,0 +1,180 @@
+import {
+  arrayFilter,
+  arrayIncludes,
+  getOwnPropertyDescriptor,
+  getOwnPropertyNames,
+  hasOwn,
+  regexpTest,
+} from './commons.js';
+
+/**
+ * keywords
+ * In JavaScript you cannot use these reserved words as variables.
+ * See 11.6.1 Identifier Names
+ */
+const keywords = [
+  // 11.6.2.1 Keywords
+  'await',
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'export',
+  'extends',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'import',
+  'in',
+  'instanceof',
+  'new',
+  'return',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield',
+
+  // Also reserved when parsing strict mode code
+  'let',
+  'static',
+
+  // 11.6.2.2 Future Reserved Words
+  'enum',
+
+  // Also reserved when parsing strict mode code
+  'implements',
+  'package',
+  'protected',
+  'interface',
+  'private',
+  'public',
+
+  // Reserved but not mentioned in specs
+  'await',
+
+  'null',
+  'true',
+  'false',
+
+  'this',
+  'arguments',
+];
+
+/**
+ * identifierPattern
+ * Simplified validation of identifier names: may only contain alphanumeric
+ * characters (or "$" or "_"), and may not start with a digit. This is safe
+ * and does not reduces the compatibility of the shim. The motivation for
+ * this limitation was to decrease the complexity of the implementation,
+ * and to maintain a resonable level of performance.
+ * Note: \w is equivalent [a-zA-Z_0-9]
+ * See 11.6.1 Identifier Names
+ */
+const identifierPattern = /^[a-zA-Z_$][\w$]*$/;
+
+/**
+ * isValidIdentifierName()
+ * What variable names might it bring into scope? These include all
+ * property names which can be variable names, including the names
+ * of inherited properties. It excludes symbols and names which are
+ * keywords. We drop symbols safely. Currently, this shim refuses
+ * service if any of the names are keywords or keyword-like. This is
+ * safe and only prevent performance optimization.
+ *
+ * @param {string} name
+ */
+export const isValidIdentifierName = name => {
+  // Ensure we have a valid identifier. We use regexpTest rather than
+  // /../.test() to guard against the case where RegExp has been poisoned.
+  return (
+    name !== 'eval' &&
+    !arrayIncludes(keywords, name) &&
+    regexpTest(identifierPattern, name)
+  );
+};
+
+/*
+ * isImmutableDataProperty
+ */
+
+function isImmutableDataProperty(obj, name) {
+  const desc = getOwnPropertyDescriptor(obj, name);
+  return (
+    desc &&
+    //
+    // The getters will not have .writable, don't let the falsyness of
+    // 'undefined' trick us: test with === false, not ! . However descriptors
+    // inherit from the (potentially poisoned) global object, so we might see
+    // extra properties which weren't really there. Accessor properties have
+    // 'get/set/enumerable/configurable', while data properties have
+    // 'value/writable/enumerable/configurable'.
+    desc.configurable === false &&
+    desc.writable === false &&
+    //
+    // Checks for data properties because they're the only ones we can
+    // optimize (accessors are most likely non-constant). Descriptors can't
+    // can't have accessors and value properties at the same time, therefore
+    // this check is sufficient. Using explicit own property deal with the
+    // case where Object.prototype has been poisoned.
+    hasOwn(desc, 'value')
+  );
+}
+
+/**
+ * getScopeConstants()
+ * What variable names might it bring into scope? These include all
+ * property names which can be variable names, including the names
+ * of inherited properties. It excludes symbols and names which are
+ * keywords. We drop symbols safely. Currently, this shim refuses
+ * service if any of the names are keywords or keyword-like. This is
+ * safe and only prevent performance optimization.
+ *
+ * @param {object} globalObject
+ * @param {object} moduleLexicals
+ */
+export const getScopeConstants = (globalObject, moduleLexicals = {}) => {
+  // getOwnPropertyNames() does ignore Symbols so we don't need to
+  // filter them out.
+  const globalObjectNames = getOwnPropertyNames(globalObject);
+  const moduleLexicalNames = getOwnPropertyNames(moduleLexicals);
+
+  // Collect all valid & immutable identifiers from the endowments.
+  const moduleLexicalConstants = arrayFilter(
+    moduleLexicalNames,
+    name =>
+      isValidIdentifierName(name) &&
+      isImmutableDataProperty(moduleLexicals, name),
+  );
+
+  // Collect all valid & immutable identifiers from the global that
+  // are also not present in the endowments (immutable or not).
+  const globalObjectConstants = arrayFilter(
+    globalObjectNames,
+    name =>
+      // Can't define a constant: it would prevent a
+      // lookup on the endowments.
+      !arrayIncludes(moduleLexicalNames, name) &&
+      isValidIdentifierName(name) &&
+      isImmutableDataProperty(globalObject, name),
+  );
+
+  return {
+    globalObjectConstants,
+    moduleLexicalConstants,
+  };
+};

package/dist/node_modules/ses/src/shim-arraybuffer-transfer.js

@@ -0,0 +1,85 @@
+import {
+  ArrayBuffer,
+  arrayBufferPrototype,
+  arrayBufferSlice,
+  arrayBufferGetByteLength,
+  Uint8Array,
+  typedArraySet,
+  globalThis,
+  TypeError,
+  defineProperty,
+} from './commons.js';
+
+export const shimArrayBufferTransfer = () => {
+  if (typeof arrayBufferPrototype.transfer === 'function') {
+    // Assume already exists so does not need to be shimmed.
+    // Such conditional shimming is ok in this case since ArrayBuffer.p.transfer
+    // is already officially part of JS.
+    //
+    // Empty object because this shim has nothing for `addIntrinsics` to add.
+    return {};
+  }
+  const clone = globalThis.structuredClone;
+  if (typeof clone !== 'function') {
+    // On a platform with neither `Array.prototype.transfer`
+    // nor `structuredClone`, this shim does nothing.
+    // For example, Node <= 16 has neither.
+    //
+    // Empty object because this shim has nothing for `addIntrinsics` to add.
+    return {};
+    // TODO Rather than doing nothing, should the endo ses-shim throw
+    // in this case?
+    // throw TypeError(
+    //   `Can only shim missing ArrayBuffer.prototype.transfer on a platform with "structuredClone"`,
+    // );
+    // For example, endo no longer supports Node <= 16. All browsers have
+    // `structuredClone`. XS has `Array.prototype.transfer`. Are there still
+    // any platforms without both that Endo should still support?
+    // What about Hermes?
+  }
+
+  /**
+   * @type {ThisType<ArrayBuffer>}
+   */
+  const methods = {
+    /**
+     * @param {number} [newLength]
+     */
+    transfer(newLength = undefined) {
+      // Using this builtin getter also ensures that `this` is a genuine
+      // ArrayBuffer.
+      const oldLength = arrayBufferGetByteLength(this);
+      if (newLength === undefined || newLength === oldLength) {
+        return clone(this, { transfer: [this] });
+      }
+      if (typeof newLength !== 'number') {
+        throw TypeError(`transfer newLength if provided must be a number`);
+      }
+      if (newLength > oldLength) {
+        const result = new ArrayBuffer(newLength);
+        const taOld = new Uint8Array(this);
+        const taNew = new Uint8Array(result);
+        typedArraySet(taNew, taOld);
+        // Using clone only to detach, and only after the copy succeeds
+        clone(this, { transfer: [this] });
+        return result;
+      } else {
+        const result = arrayBufferSlice(this, 0, newLength);
+        // Using clone only to detach, and only after the slice succeeds
+        clone(this, { transfer: [this] });
+        return result;
+      }
+    },
+  };
+
+  defineProperty(arrayBufferPrototype, 'transfer', {
+    // @ts-expect-error
+    value: methods.transfer,
+    writable: true,
+    enumerable: false,
+    configurable: true,
+  });
+
+  // Empty object because this shim has nothing for `addIntrinsics` to add.
+  return {};
+};

package/dist/node_modules/ses/src/sloppy-globals-scope-terminator.js

@@ -0,0 +1,61 @@
+import {
+  Proxy,
+  create,
+  freeze,
+  getOwnPropertyDescriptors,
+  reflectSet,
+} from './commons.js';
+import {
+  strictScopeTerminatorHandler,
+  alwaysThrowHandler,
+} from './strict-scope-terminator.js';
+
+/**
+ * `freeze` but not `harden` the proxy target so it remains trapping.
+ * Thus, it should not be shared outside this module.
+ *
+ * @see https://github.com/endojs/endo/blob/master/packages/ses/docs/preparing-for-stabilize.md
+ */
+const objTarget = freeze({ __proto__: null });
+
+/*
+ * createSloppyGlobalsScopeTerminator()
+ * strictScopeTerminatorHandler manages a scopeTerminator Proxy which serves as
+ * the final scope boundary that will always return "undefined" in order
+ * to prevent access to "start compartment globals". When "sloppyGlobalsMode"
+ * is true, the Proxy will perform sets on the "globalObject".
+ */
+export const createSloppyGlobalsScopeTerminator = globalObject => {
+  const scopeProxyHandlerProperties = {
+    // inherit scopeTerminator behavior
+    ...strictScopeTerminatorHandler,
+
+    // Redirect set properties to the globalObject.
+    set(_shadow, prop, value) {
+      return reflectSet(globalObject, prop, value);
+    },
+
+    // Always claim to have a potential property in order to be the recipient of a set
+    has(_shadow, _prop) {
+      return true;
+    },
+  };
+
+  // The scope handler's prototype is a proxy that throws if any trap other
+  // than get/set/has are run (like getOwnPropertyDescriptors, apply,
+  // getPrototypeOf).
+  const sloppyGlobalsScopeTerminatorHandler = freeze(
+    create(
+      alwaysThrowHandler,
+      getOwnPropertyDescriptors(scopeProxyHandlerProperties),
+    ),
+  );
+
+  const sloppyGlobalsScopeTerminator = new Proxy(
+    objTarget,
+    sloppyGlobalsScopeTerminatorHandler,
+  );
+
+  return sloppyGlobalsScopeTerminator;
+};
+freeze(createSloppyGlobalsScopeTerminator);

package/dist/node_modules/ses/src/strict-scope-terminator.js

@@ -0,0 +1,99 @@
+import {
+  Proxy,
+  String,
+  TypeError,
+  ReferenceError,
+  create,
+  freeze,
+  getOwnPropertyDescriptors,
+} from './commons.js';
+import { assert } from './error/assert.js';
+
+const { Fail, quote: q } = assert;
+
+/**
+ * `freeze` but not `harden` the proxy target so it remains trapping.
+ * Thus, it should not be shared outside this module.
+ *
+ * @see https://github.com/endojs/endo/blob/master/packages/ses/docs/preparing-for-stabilize.md
+ */
+const objTarget = freeze({ __proto__: null });
+
+/**
+ * alwaysThrowHandler
+ * This is an object that throws if any property is called. It's used as
+ * a proxy handler which throws on any trap called.
+ * It's made from a proxy with a get trap that throws. It's safe to
+ * create one and share it between all Proxy handlers.
+ */
+export const alwaysThrowHandler = new Proxy(
+  objTarget,
+  freeze({
+    get(_shadow, prop) {
+      Fail`Please report unexpected scope handler trap: ${q(String(prop))}`;
+    },
+  }),
+);
+
+/*
+ * scopeProxyHandlerProperties
+ * scopeTerminatorHandler manages a strictScopeTerminator Proxy which serves as
+ * the final scope boundary that will always return "undefined" in order
+ * to prevent access to "start compartment globals".
+ */
+const scopeProxyHandlerProperties = {
+  get(_shadow, _prop) {
+    return undefined;
+  },
+
+  set(_shadow, prop, _value) {
+    // We should only hit this if the has() hook returned true matches the v8
+    // ReferenceError message "Uncaught ReferenceError: xyz is not defined"
+    throw ReferenceError(`${String(prop)} is not defined`);
+  },
+
+  has(_shadow, prop) {
+    // we must at least return true for all properties on the realm globalThis
+    return true;
+  },
+
+  // note: this is likely a bug of safari
+  // https://bugs.webkit.org/show_bug.cgi?id=195534
+  getPrototypeOf(_shadow) {
+    return null;
+  },
+
+  // See https://github.com/endojs/endo/issues/1510
+  // TODO: report as bug to v8 or Chrome, and record issue link here.
+  getOwnPropertyDescriptor(_shadow, prop) {
+    // Coerce with `String` in case prop is a symbol.
+    const quotedProp = q(String(prop));
+    // eslint-disable-next-line @endo/no-polymorphic-call
+    console.warn(
+      `getOwnPropertyDescriptor trap on scopeTerminatorHandler for ${quotedProp}`,
+      TypeError().stack,
+    );
+    return undefined;
+  },
+
+  // See https://github.com/endojs/endo/issues/1490
+  // TODO Report bug to JSC or Safari
+  ownKeys(_shadow) {
+    return [];
+  },
+};
+
+// The scope handler's prototype is a proxy that throws if any trap other
+// than get/set/has are run (like getOwnPropertyDescriptors, apply,
+// getPrototypeOf).
+export const strictScopeTerminatorHandler = freeze(
+  create(
+    alwaysThrowHandler,
+    getOwnPropertyDescriptors(scopeProxyHandlerProperties),
+  ),
+);
+
+export const strictScopeTerminator = new Proxy(
+  objTarget,
+  strictScopeTerminatorHandler,
+);

package/dist/node_modules/ses/src/tame-date-constructor.js

@@ -0,0 +1,127 @@
+// @ts-check
+
+import {
+  Date,
+  TypeError,
+  apply,
+  construct,
+  defineProperties,
+} from './commons.js';
+
+export default function tameDateConstructor() {
+  const OriginalDate = Date;
+  const DatePrototype = OriginalDate.prototype;
+
+  // Use concise methods to obtain named functions without constructors.
+  const tamedMethods = {
+    /**
+     * `%SharedDate%.now()` throw a `TypeError` starting with "secure mode".
+     * See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
+     */
+    now() {
+      throw TypeError('secure mode Calling %SharedDate%.now() throws');
+    },
+  };
+
+  /**
+   * Tame the Date constructor.
+   * See https://github.com/endojs/endo/issues/910#issuecomment-1581855420
+   *
+   * Common behavior
+   *   * `new Date(x)` coerces x into a number and then returns a Date
+   *     for that number of millis since the epoch
+   *   * `new Date(NaN)` returns a Date object which stringifies to
+   *     'Invalid Date'
+   *   * `new Date(undefined)` returns a Date object which stringifies to
+   *     'Invalid Date'
+   *
+   * OriginalDate (normal standard) behavior preserved by
+   * `%InitialDate%`.
+   *   * `Date(anything)` gives a string with the current time
+   *   * `new Date()` returns the current time, as a Date object
+   *
+   * `%SharedDate%` behavior
+   *   * `Date(anything)` throws a TypeError starting with "secure mode"
+   *   * `new Date()` throws a TypeError starting with "secure mode"
+   *
+   * @param {{powers?: string}} [opts]
+   */
+  const makeDateConstructor = ({ powers = 'none' } = {}) => {
+    let ResultDate;
+    if (powers === 'original') {
+      // eslint-disable-next-line no-shadow
+      ResultDate = function Date(...rest) {
+        if (new.target === undefined) {
+          return apply(OriginalDate, undefined, rest);
+        }
+        return construct(OriginalDate, rest, new.target);
+      };
+    } else {
+      // eslint-disable-next-line no-shadow
+      ResultDate = function Date(...rest) {
+        if (new.target === undefined) {
+          throw TypeError(
+            'secure mode Calling %SharedDate% constructor as a function throws',
+          );
+        }
+        if (rest.length === 0) {
+          throw TypeError(
+            'secure mode Calling new %SharedDate%() with no arguments throws',
+          );
+        }
+        return construct(OriginalDate, rest, new.target);
+      };
+    }
+
+    defineProperties(ResultDate, {
+      length: { value: 7 },
+      prototype: {
+        value: DatePrototype,
+        writable: false,
+        enumerable: false,
+        configurable: false,
+      },
+      parse: {
+        value: OriginalDate.parse,
+        writable: true,
+        enumerable: false,
+        configurable: true,
+      },
+      UTC: {
+        value: OriginalDate.UTC,
+        writable: true,
+        enumerable: false,
+        configurable: true,
+      },
+    });
+    return ResultDate;
+  };
+  const InitialDate = makeDateConstructor({ powers: 'original' });
+  const SharedDate = makeDateConstructor({ powers: 'none' });
+
+  defineProperties(InitialDate, {
+    now: {
+      value: OriginalDate.now,
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    },
+  });
+  defineProperties(SharedDate, {
+    now: {
+      value: tamedMethods.now,
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    },
+  });
+
+  defineProperties(DatePrototype, {
+    constructor: { value: SharedDate },
+  });
+
+  return {
+    '%InitialDate%': InitialDate,
+    '%SharedDate%': SharedDate,
+  };
+}