lib0 1.0.0-rc.2 → 1.0.0-rc.21

package/src/delta/transformer/rename.js

@@ -0,0 +1,84 @@
+import * as delta from '../delta.js'
+import { Transformer, Template, createTransformResult, withName } from './core.js'
+
+/**
+ * Relabels a node: side B carries the configured `name`, side A keeps the source node's original
+ * name. Otherwise identity. Useful to mark a `children`-mapped collection as `lib0:inline` (so a
+ * downstream {@link import('./inline.js').inline}`(['lib0:inline'])` splices it into its parent) or
+ * simply to rename the container (e.g. a data collection projected as a `<ul>`).
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class RenameTransformer extends Transformer {
+  /**
+   * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+   * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+   * @param {string} name
+   */
+  constructor ($in, $out, name) {
+    super($in, $out)
+    this.target = name
+    /** @type {string|undefined} */
+    this.srcName = undefined
+  }
+
+  /**
+   * @param {delta.DeltaBuilderAny} d
+   * @return {import('./core.js').TransformResultAny}
+   */
+  applyA (d) {
+    if (d.name != null) this.srcName = d.name
+    const out = delta.clone(d)
+    out.name = /** @type {any} */ (this.target)
+    return createTransformResult(null, out)
+  }
+
+  /**
+   * @param {delta.DeltaBuilderAny} d
+   * @return {import('./core.js').TransformResultAny}
+   */
+  applyB (d) {
+    const out = delta.clone(d)
+    out.name = /** @type {any} */ (this.srcName)
+    return createTransformResult(out, null)
+  }
+}
+
+/**
+ * Template for {@link RenameTransformer}.
+ *
+ * @template {string} Name
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, delta.DeltaConfOverwrite<IN, { name: Name }>>}
+ */
+export class Rename extends Template {
+  /**
+   * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+   * @param {Name} name
+   */
+  constructor ($d, name) {
+    super($d, /** @type {any} */ (withName($d, name)))
+    this.target = name
+  }
+
+  get name () { return 'lib0:rename:' + this.target }
+
+  /**
+   * @return {Transformer<IN, delta.DeltaConfOverwrite<IN, { name: Name }>>}
+   */
+  init () {
+    return /** @type {any} */ (new RenameTransformer(this.$in, this.$out, this.target))
+  }
+}
+
+/**
+ * Relabel a node to `name` (side B) and back (side A). Returns a reusable {@link Rename} template
+ * (a `project` hole, or `.init()` for a standalone transformer).
+ *
+ * @template {delta.DeltaConf} IN
+ * @template {string} Name
+ * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+ * @param {Name} name
+ * @return {Rename<Name, IN>}
+ */
+export const rename = ($d, name) => new Rename($d, name)

package/src/delta/transformer/value.js

@@ -0,0 +1,214 @@
+import * as delta from '../delta.js'
+import * as math from '../../math.js'
+import { Transformer, Template, createTransformResult } from './core.js'
+
+/**
+ * A `lib0:value` carrier node holds a single scalar in its `value` attribute (the convention
+ * established by the {@link import('./attr.js').attr} transformer). At a *child* position such a
+ * node is resolved to a one-position **embed** of that scalar; at an *attr* position carriers are
+ * resolved by {@link import('./project.js').project} itself (it owns the position knowledge).
+ *
+ * @param {any} el
+ * @return {boolean}
+ */
+const isValueNode = el => delta.$deltaAny.check(el) && el.name === 'lib0:value'
+
+/**
+ * The scalar carried by a `lib0:value` delta (its `value` attribute op's value), or `undefined`.
+ *
+ * @param {delta.DeltaAny} el
+ */
+const valueOf = el => /** @type {any} */ (el.attrs).value?.value
+
+/**
+ * Stateful transformer that resolves `lib0:value` carrier *children* of a node: a `lib0:value` node
+ * (1 position) becomes an embed of its scalar value (1 position), and back. Count-preserving, so a
+ * single sparse positional map (`insert([1])` at carrier positions, coalesced `retain(n)` over
+ * gaps) indexes both directions - the same `childTs` technique as {@link import('./children.js')}.
+ *
+ * A standalone, *composable* one-level resolver (the `lib0:value` counterpart of
+ * {@link import('./inline.js').inline}`(['lib0:inline'])`): place it after any transformer that emits
+ * `lib0:value` carriers, or compose it with {@link import('./children.js').children} to descend into
+ * deeper levels. `project` lifts the carriers in its *own* structure, so `unwrapValue` is only needed
+ * for carriers emitted by a non-`project` transformer.
+ *
+ * Editing a resolved scalar from side B (the view) is not round-tripped in v1: a value *update*
+ * driven from side A (a `modify` on the carrier) maps to `delete(1).insert([newValue])`, but a side
+ * B `delete`+`insert` of the embed is treated structurally.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class UnwrapValueTransformer extends Transformer {
+  /**
+   * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+   * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+   */
+  constructor ($in, $out) {
+    super($in, $out)
+    /**
+     * Sparse positional map of carriers: `insert([1])` at each `lib0:value` child, `retain(n)` over
+     * gaps (text and pass-through nodes).
+     *
+     * @type {delta.DeltaBuilderAny}
+     */
+    this.map = delta.create()
+  }
+
+  /**
+   * @param {delta.DeltaBuilderAny} d the change to map
+   * @param {boolean} fwd `true` maps side A (carriers present) -> B (resolved), `false` maps back
+   * @return {import('./core.js').TransformResultAny}
+   */
+  transform (d, fwd) {
+    // `cloneShallow` carries the node's name, attribute ops, and own (root) marks; only child nodes are
+    // (re)built below, and nested children's marks ride on those rebuilt children. It is the shared
+    // mark-carrying primitive, so this node's marks cannot be silently dropped. `any` keeps `out` within
+    // the shared TS instantiation budget (see {@link import('./inline.js')}).
+    const out = /** @type {any} */ (delta.cloneShallow(d))
+    const newMap = delta.create()
+    let srcNode = this.map.children.start
+    let srcOff = 0
+    /**
+     * Copy `n` positions from the old map to `newMap`, advancing the cursor.
+     *
+     * @param {number} n
+     */
+    const carry = n => {
+      let rem = n
+      while (rem > 0 && srcNode != null) {
+        const take = math.min(srcNode.length - srcOff, rem)
+        if (delta.$insertOp.check(srcNode)) {
+          newMap.insert(srcNode.insert.slice(srcOff, srcOff + take))
+        } else {
+          newMap.retain(take)
+        }
+        srcOff += take
+        rem -= take
+        if (srcOff >= srcNode.length) { srcNode = srcNode.next; srcOff = 0 }
+      }
+    }
+    /**
+     * Advance the cursor `n` positions without copying.
+     *
+     * @param {number} n
+     */
+    const drop = n => {
+      let rem = n
+      while (rem > 0 && srcNode != null) {
+        const take = math.min(srcNode.length - srcOff, rem)
+        srcOff += take
+        rem -= take
+        if (srcOff >= srcNode.length) { srcNode = srcNode.next; srcOff = 0 }
+      }
+    }
+    // whether the cursor currently sits on a carrier position
+    const peekCarrier = () => srcNode != null && delta.$insertOp.check(srcNode)
+    for (const op of d.children) {
+      if (delta.$retainOp.check(op)) {
+        out.retain(op.retain, op.format, op.attribution)
+        carry(op.retain)
+      } else if (delta.$textOp.check(op)) {
+        out.insert(op.insert, op.format, op.attribution)
+        newMap.retain(op.insert.length) // text is a gap
+      } else if (delta.$insertOp.check(op)) {
+        for (const el of op.insert) {
+          if (fwd && isValueNode(el)) {
+            out.insert([valueOf(el)], op.format, op.attribution)
+            newMap.insert([1]) // mark carrier
+          } else {
+            out.insert([el], op.format, op.attribution)
+            newMap.retain(1) // pass-through / literal
+          }
+        }
+      } else if (delta.$deleteOp.check(op)) {
+        out.delete(op.delete)
+        drop(op.delete)
+      } else if (delta.$modifyOp.check(op)) {
+        if (fwd && peekCarrier()) {
+          // a value update arrives as a `modify` on the carrier node setting its `value` attr
+          const newV = /** @type {any} */ (op.value.attrs).value?.value
+          if (newV !== undefined) {
+            out.delete(1)
+            out.insert([newV], op.format, op.attribution)
+          } else {
+            out.retain(1, op.format, op.attribution)
+          }
+        } else {
+          out.modify(delta.clone(op.value), op.format, op.attribution)
+        }
+        carry(1)
+      }
+    }
+    carry(Infinity) // trailing untouched positions
+    out.done(false)
+    this.map = newMap
+    return fwd ? createTransformResult(null, out) : createTransformResult(out, null)
+  }
+
+  /**
+   * @param {delta.DeltaBuilderAny} da
+   */
+  applyA (da) {
+    return this.transform(da, true)
+  }
+
+  /**
+   * @param {delta.DeltaBuilderAny} db
+   */
+  applyB (db) {
+    return this.transform(db, false)
+  }
+}
+
+/**
+ * A `lib0:value` carrier child lifts to its scalar `value` type; any other child passes through.
+ * Naked-param conditional, so it distributes over a children union.
+ *
+ * @template C
+ * @typedef {C extends delta.Delta<{ name: 'lib0:value', attrs: { value: infer V extends import('../../trait/fingerprint.js').Fingerprintable } }> ? V : C} UnwrapValueChild
+ */
+
+/**
+ * `unwrapValue`'s output conf: `IN` with every `lib0:value` carrier child replaced by its lifted
+ * scalar (see {@link UnwrapValueChild}); name/attrs/text unchanged.
+ *
+ * @template {delta.DeltaConf} IN
+ * @typedef {import('./core.js').ResolveOut<delta.DeltaConfOverwrite<IN, { children: UnwrapValueChild<delta.DeltaConfGetChildren<IN>> }>>} UnwrapValueOut
+ */
+
+/**
+ * Template for {@link UnwrapValueTransformer}.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, UnwrapValueOut<IN>>}
+ */
+export class UnwrapValue extends Template {
+  /**
+   * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+   */
+  constructor ($d) {
+    super($d, /** @type {any} */ (delta.$deltaAny))
+  }
+
+  get name () { return 'lib0:unwrapValue' }
+
+  /**
+   * @return {Transformer<IN, UnwrapValueOut<IN>>}
+   */
+  init () {
+    return /** @type {any} */ (new UnwrapValueTransformer(this.$in, this.$out))
+  }
+}
+
+/**
+ * Resolve `lib0:value` carrier *children* to embeds of their scalar value (and back). One level
+ * only; compose with {@link import('./children.js').children} to descend. A flat, composable resolver
+ * for carriers emitted *outside* a `project` (which lifts its own); symmetric with
+ * {@link import('./inline.js').inline}`(['lib0:inline'])`. Returns a reusable {@link UnwrapValue}
+ * template (`.init()` for a standalone transformer).
+ *
+ * @template {delta.DeltaConf} IN
+ * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+ * @return {UnwrapValue<IN>}
+ */
+export const unwrapValue = $d => new UnwrapValue($d)

package/src/delta/transformer.js

@@ -0,0 +1,38 @@
+/**
+ * # Delta transformers
+ *
+ * A {@link Template} is a composable transformer factory; its `init($schema)` produces a stateful
+ * {@link Transformer} that maps changes ("deltas") of one delta shape (side A) onto another (side B)
+ * and back. Transformers compose with {@link pipe}.
+ *
+ * Each concrete transformer lives in `./transformer/` and is re-exported here so the whole set is
+ * available from a single module (`lib0/delta/transformer`):
+ * - {@link id} — identity (both sides stay equal)
+ * - {@link renameAttrs} — rename node attributes
+ * - {@link conform} — drop everything the target schema does not recognize
+ * - {@link pipe} — chain templates
+ * - {@link attr} — project a single attribute into a `lib0:value` node
+ * - {@link inline} — inline child nodes whose name is in a configured set
+ * - {@link children} — descend into child nodes and apply a per-child sub-transformer
+ * - {@link project} — project the data onto a fixed structure (spec) with embedded "holes"
+ * - {@link unwrapValue} — composable resolver for `lib0:value` carrier children (scalar lift)
+ * - {@link rename} — rename a node's name (e.g. mark a `children`-map as `lib0:inline`)
+ * - {@link attributionToFormat} — render the `attribution` dimension as `y-attributed-*` formats
+ * - {@link fullAttributions} — re-emit the complete accumulated attribution on every attribution change
+ *
+ * @module delta/transformer
+ */
+
+export * from './transformer/core.js'
+export * from './transformer/id.js'
+export * from './transformer/rename.js'
+export * from './transformer/conform.js'
+export * from './transformer/pipe.js'
+export * from './transformer/attr.js'
+export * from './transformer/inline.js'
+export * from './transformer/children.js'
+export * from './transformer/project.js'
+export * from './transformer/value.js'
+export * from './transformer/rename-attrs.js'
+export * from './transformer/attribution-to-format.js'
+export * from './transformer/full-attributions.js'

package/src/diff/patience.js

@@ -16,7 +16,7 @@ import * as array from '../array.js'
  *
  * @param {Array<string>} as
  * @param {Array<string>} bs
- * @return {Array<{ index: number, remove: Array<string>, insert: Array<string>}>} changeset @todo should use delta instead
+ * @return {Array<{ index: number, remove: Array<string>, insert: Array<string>}>} changeset
  */
 export const diff = (as, bs) => {
   const {
@@ -30,14 +30,16 @@ export const diff = (as, bs) => {
 /**
  * @param {string} a
  * @param {string} b
- * @param {RegExp|string} _regexp
+ * @param {RegExp|string} regexp
  */
-export const diffSplitBy = (a, b, _regexp) => {
-  const isStringSeparator = typeof _regexp === 'string'
-  const separator = isStringSeparator ? _regexp : ''
-  const regexp = isStringSeparator ? new RegExp(_regexp, 'g') : _regexp
-  const as = splitByRegexp(a, regexp, !isStringSeparator)
-  const bs = splitByRegexp(b, regexp, !isStringSeparator)
+export const diffSplitBy = (a, b, regexp) => {
+  const isStringSeparator = typeof regexp === 'string'
+  const separator = /** @type {string} */ (isStringSeparator ? regexp : '')
+  if (isStringSeparator) {
+    regexp = new RegExp(regexp, 'g')
+  }
+  const as = splitByRegexp(a, /** @type {RegExp} */ (regexp), !isStringSeparator)
+  const bs = splitByRegexp(b, /** @type {RegExp} */ (regexp), !isStringSeparator)
   const changes = diff(as, bs)
   let prevSplitIndex = 0
   let prevStringIndex = 0
@@ -53,6 +55,15 @@ export const diffSplitBy = (a, b, _regexp) => {
   })
 }
 
+/**
+ * Idea: match all "non-word" characters and keep them separate (spaces, comma, exclamation marks, ..).
+ * Anything that can be classivied as a word (emoji, char, number) will be bundled together. All other tokens are kept
+ * individually. "hello, world!!!!" => ['hello', ',', ' ', 'world', '!', '!']
+ *
+ * @experimental
+ */
+export const smartSplitRegex = /[^\p{L}\p{N}\p{Extended_Pictographic}\p{Emoji_Modifier}\u200D\uFE0F]/gu // eslint-disable-line no-misleading-character-class
+
 /**
  * Sensible default for diffing strings using patience (it's fast though).
  *
@@ -64,12 +75,12 @@ export const diffSplitBy = (a, b, _regexp) => {
  */
 export const diffAuto = (a, b) =>
   diffSplitBy(a, b, '\n').map(d =>
-    diffSplitBy(d.remove, d.insert, /\. |[a-zA-Z0-9]+|[. ()[\],;{}]/g).map(dd => ({
+    diffSplitBy(d.remove, d.insert, smartSplitRegex).map(dd => ({ // old regex: /\. |[a-zA-Z0-9]+|[. ()[\],;{}]/g
       insert: dd.insert,
       remove: dd.remove,
       index: dd.index + d.index
     }))
-  ).flat()
+  ).flat(1)
 
 /**
  * @param {Array<string>} as
@@ -97,7 +108,7 @@ const removeCommonPrefixAndSuffix = (as, bs) => {
  * @param {RegExp} regexp
  * @param {boolean} includeSeparator
  */
-const splitByRegexp = (str, regexp, includeSeparator) => {
+export const splitByRegexp = (str, regexp, includeSeparator) => {
   const matches = [...str.matchAll(regexp)]
   let prevIndex = 0
   /**

package/src/dom.js

@@ -14,7 +14,7 @@ import * as $ from './schema.js'
 /**
  * @type {Document}
  */
-export const doc = /** @type {Document} */ (typeof document !== 'undefined' ? document : {})
+export const doc = /** @type {Document} */ (/* @__PURE__ */ (() => typeof document !== 'undefined' ? document : {})())
 
 /**
  * @param {string} name
@@ -38,7 +38,7 @@ export const $fragment = $.$custom(el => el.nodeType === DOCUMENT_FRAGMENT_NODE)
  */
 export const createTextNode = text => doc.createTextNode(text)
 
-export const domParser = /** @type {DOMParser} */ (typeof DOMParser !== 'undefined' ? new DOMParser() : null)
+export const domParser = /** @type {DOMParser} */ (/* @__PURE__ */ (() => typeof DOMParser !== 'undefined' ? new DOMParser() : null)())
 
 /**
  * @param {HTMLElement} el

package/src/encoding.js

@@ -341,7 +341,7 @@ export const _writeVarStringPolyfill = (encoder, str) => {
  * @param {String} str The string that is to be encoded.
  */
 /* c8 ignore next */
-export const writeVarString = (string.utf8TextEncoder && /** @type {any} */ (string.utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill
+export const writeVarString = /* @__PURE__ */(() => (string.utf8TextEncoder && /** @type {any} */ (string.utf8TextEncoder).encodeInto) ? _writeVarStringNative : _writeVarStringPolyfill)()
 
 /**
  * Write a string terminated by a special byte sequence. This is not very performant and is

package/src/environment.js

@@ -13,11 +13,26 @@ import * as f from './function.js'
 /* c8 ignore next */
 export const isNode = /* @__PURE__ */(() => typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]')()
 
+/**
+ * True iff this script is running in deno
+ * @type {boolean}
+ */
+/* c8 ignore next 2 */
+// @ts-ignore
+export const isDeno = /* @__PURE__ */(() => typeof Deno !== 'undefined')()
+
 /* c8 ignore next */
 export const isBrowser = /* @__PURE__ */(() => typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode)()
 /* c8 ignore next */
 export const isMac = /* @__PURE__ */(() => typeof navigator !== 'undefined' ? /Mac/.test(navigator.platform) : false)()
 
+/**
+ * True iff a DOM is available — either a real browser, or Node with a jsdom shim installed (see
+ * `src/test-setup.js`). Gate DOM-dependent tests on this so they run in the browser AND under jsdom.
+ */
+/* c8 ignore next */
+export const hasDom = /* @__PURE__ */(() => typeof document !== 'undefined' && typeof MutationObserver !== 'undefined')()
+
 /**
  * @type {Map<string,string>}
  */

package/src/hash/fnv1a.js

@@ -0,0 +1,82 @@
+/**
+ * @module fnv1a
+ * FNV-1a (32bit) - a fast, non-cryptographic hash function.
+ * Spec: http://www.isthe.com/chongo/tech/comp/fnv/
+ */
+
+import * as math from '../math.js'
+
+/**
+ * FNV-1a offset basis (32bit).
+ */
+export const offsetBasis = 0x811c9dc5
+
+/**
+ * FNV-1a prime (32bit).
+ */
+export const prime = 0x01000193
+
+/**
+ * Compute the FNV-1a 32bit hash of a byte sequence.
+ *
+ * Pass the result of a previous call as `hash` to digest a message in chunks:
+ * `digest(concat(a, b)) === digest(b, digest(a))`.
+ *
+ * @param {Uint8Array} data
+ * @param {number} hash - continue hashing from a previous result (defaults to the offset basis)
+ * @return {number} unsigned 32bit hash
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const digest = (data, hash = offsetBasis) => {
+  for (let i = 0; i < data.length; i++) {
+    hash = math.imul(hash ^ data[i], prime)
+  }
+  return hash >>> 0
+}
+
+/**
+ * Compute the FNV-1a 32bit hash of a string - without allocating the utf8 encoding.
+ *
+ * Equivalent to `digest(string.encodeUtf8(str))`: the string is hashed as utf8 bytes; lone
+ * surrogates are hashed as the replacement character (like TextEncoder encodes them).
+ *
+ * Prefer this over `digest(string.encodeUtf8(str))` when hashing strings - it skips the
+ * TextEncoder call and the Uint8Array allocation, making it ~5x faster for small strings
+ * (<=20 chars, e.g. object keys) and ~2x faster for larger ones.
+ *
+ * @param {string} str
+ * @param {number} hash - continue hashing from a previous result (defaults to the offset basis)
+ * @return {number} unsigned 32bit hash
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const digestString = (str, hash = offsetBasis) => {
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i)
+    if (c < 0x80) {
+      hash = math.imul(hash ^ c, prime)
+    } else {
+      if (c >= 0xd800 && c < 0xe000) {
+        const lo = str.charCodeAt(i + 1) // NaN when out of bounds ⇒ NaN & x === 0
+        if (c < 0xdc00 && (lo & 0xfc00) === 0xdc00) {
+          c = 0x10000 + ((c & 0x3ff) << 10) + (lo & 0x3ff)
+          i++
+        } else {
+          c = 0xfffd // lone surrogate ⇒ replacement character
+        }
+      }
+      if (c < 0x800) {
+        hash = math.imul(hash ^ (0xc0 | (c >> 6)), prime)
+      } else {
+        if (c < 0x10000) {
+          hash = math.imul(hash ^ (0xe0 | (c >> 12)), prime)
+        } else {
+          hash = math.imul(hash ^ (0xf0 | (c >> 18)), prime)
+          hash = math.imul(hash ^ (0x80 | ((c >> 12) & 0x3f)), prime)
+        }
+        hash = math.imul(hash ^ (0x80 | ((c >> 6) & 0x3f)), prime)
+      }
+      hash = math.imul(hash ^ (0x80 | (c & 0x3f)), prime)
+    }
+  }
+  return hash >>> 0
+}

package/src/number.js

@@ -4,7 +4,6 @@
  * @module number
  */
 
-import * as math from './math.js'
 import * as binary from './binary.js'
 
 export const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER
@@ -14,8 +13,7 @@ export const LOWEST_INT32 = 1 << 31
 export const HIGHEST_INT32 = binary.BITS31
 export const HIGHEST_UINT32 = binary.BITS32
 
-/* c8 ignore next */
-export const isInteger = Number.isInteger || (num => typeof num === 'number' && isFinite(num) && math.floor(num) === num)
+export const isInteger = Number.isInteger
 export const isNaN = Number.isNaN
 export const parseInt = Number.parseInt
 

package/src/performance.node.js

@@ -6,16 +6,16 @@ import * as time from './time.js'
  * @type {typeof performance.measure}
  */
 /* c8 ignore next */
-export const measure = performance.measure ? performance.measure.bind(performance) : /** @type {any} */ (nop)
+export const measure = /* @__PURE__ */(() => performance.measure ? performance.measure.bind(performance) : /** @type {any} */ (nop))()
 
 /**
  * @type {typeof performance.now}
  */
 /* c8 ignore next */
-export const now = performance.now ? performance.now.bind(performance) : time.getUnixTime
+export const now = /* @__PURE__ */(() => performance.now ? performance.now.bind(performance) : time.getUnixTime)()
 
 /**
  * @type {typeof performance.mark}
  */
 /* c8 ignore next */
-export const mark = performance.mark ? performance.mark.bind(performance) : /** @type {any} */ (nop)
+export const mark = /* @__PURE__ */(() => performance.mark ? performance.mark.bind(performance) : /** @type {any} */ (nop))()