@teammy/server 0.1.4 → 0.1.6

package/node_modules/glob/src/walker.ts

@@ -0,0 +1,523 @@
+/**
+ * Single-use utility classes to provide functionality to the {@link Glob}
+ * methods.
+ *
+ * @module
+ */
+import { Minipass } from 'minipass'
+import type { Form } from 'minimatch'
+import type { Path } from 'path-scurry'
+import type { IgnoreLike } from './ignore.js'
+import { Ignore } from './ignore.js'
+
+// XXX can we somehow make it so that it NEVER processes a given path more than
+// once, enough that the match set tracking is no longer needed?  that'd speed
+// things up a lot.  Or maybe bring back nounique, and skip it in that case?
+
+// a single minimatch set entry with 1 or more parts
+import type { Pattern } from './pattern.js'
+import { MatchRecord, Processor } from './processor.js'
+
+const { ABSOLUTE, IF_DIR } = MatchRecord
+
+export interface GlobWalkerOpts {
+  absolute?: boolean
+  allowWindowsEscape?: boolean
+  cwd?: string | URL
+  dot?: boolean
+  dotRelative?: boolean
+  follow?: boolean
+  ignore?: string | string[] | IgnoreLike | ReadonlyArray<string>
+  mark?: boolean
+  matchBase?: boolean
+  // Note: maxDepth here means "maximum actual Path.depth()",
+  // not "maximum depth beyond cwd"
+  maxDepth?: number
+  nobrace?: boolean
+  nocase?: boolean
+  nodir?: boolean
+  noext?: boolean
+  noglobstar?: boolean
+  normalize?: boolean | Form
+  platform?: NodeJS.Platform
+  posix?: boolean
+  realpath?: boolean
+  root?: string
+  stat?: boolean
+  signal?: AbortSignal
+  windowsPathsNoEscape?: boolean
+  withFileTypes?: boolean
+  includeChildMatches?: boolean
+}
+
+export type GWOFileTypesTrue = GlobWalkerOpts & {
+  withFileTypes: true
+}
+export type GWOFileTypesFalse = GlobWalkerOpts & {
+  withFileTypes: false
+}
+export type GWOFileTypesUnset = GlobWalkerOpts & {
+  withFileTypes?: undefined
+}
+
+export type Result<O extends GlobWalkerOpts> =
+  O extends GWOFileTypesTrue ? Path
+  : O extends GWOFileTypesFalse ? string
+  : O extends GWOFileTypesUnset ? string
+  : Path | string
+
+export type Matches<O extends GlobWalkerOpts> =
+  O extends GWOFileTypesTrue ? Path[]
+  : O extends GWOFileTypesFalse ? string[]
+  : O extends GWOFileTypesUnset ? string[]
+  : (Path | string)[]
+
+export type MatchStream<O extends GlobWalkerOpts> = Minipass<
+  Result<O>,
+  Result<O>
+>
+
+const makeIgnore = (
+  ignore: string | string[] | IgnoreLike | ReadonlyArray<string>,
+  opts: GlobWalkerOpts,
+  cwd: Path,
+): IgnoreLike =>
+  typeof ignore === 'string' ? new Ignore([ignore], opts, cwd)
+  : Array.isArray(ignore) ? new Ignore(ignore, opts, cwd)
+  : (ignore as IgnoreLike)
+
+/**
+ * basic walking utilities that all the glob walker types use
+ */
+export abstract class GlobUtil<O extends GlobWalkerOpts = GlobWalkerOpts> {
+  path: Path
+  patterns: Pattern[]
+  opts: O
+  seen: Set<Path> = new Set<Path>()
+  paused: boolean = false
+  aborted: boolean = false
+  #onResume: (() => unknown)[] = []
+  #ignore?: IgnoreLike
+  #sep: '\\' | '/'
+  signal?: AbortSignal
+  maxDepth: number
+  includeChildMatches: boolean
+
+  constructor(patterns: Pattern[], path: Path, opts: O)
+  constructor(patterns: Pattern[], path: Path, opts: O) {
+    this.patterns = patterns
+    this.path = path
+    this.opts = opts
+    this.#sep = !opts.posix && opts.platform === 'win32' ? '\\' : '/'
+    this.includeChildMatches = opts.includeChildMatches !== false
+    if (opts.ignore || !this.includeChildMatches) {
+      this.#ignore = makeIgnore(opts.ignore ?? [], opts, path)
+      if (
+        !this.includeChildMatches &&
+        typeof this.#ignore.add !== 'function'
+      ) {
+        const m = 'cannot ignore child matches, ignore lacks add() method.'
+        throw new Error(m)
+      }
+    }
+    // ignore, always set with maxDepth, but it's optional on the
+    // GlobOptions type
+    /* c8 ignore start */
+    this.maxDepth = opts.maxDepth || Infinity
+    /* c8 ignore stop */
+    if (opts.signal) {
+      this.signal = opts.signal
+      this.signal.addEventListener('abort', () => {
+        this.#onResume.length = 0
+      })
+    }
+  }
+
+  #ignored(path: Path): boolean {
+    return this.seen.has(path) || !!this.#ignore?.ignored?.(path)
+  }
+  #childrenIgnored(path: Path): boolean {
+    return !!this.#ignore?.childrenIgnored?.(path)
+  }
+
+  // backpressure mechanism
+  pause() {
+    this.paused = true
+  }
+  resume() {
+    /* c8 ignore start */
+    if (this.signal?.aborted) return
+    /* c8 ignore stop */
+    this.paused = false
+    let fn: (() => unknown) | undefined = undefined
+    while (!this.paused && (fn = this.#onResume.shift())) {
+      fn()
+    }
+  }
+  onResume(fn: () => unknown) {
+    /* c8 ignore start */
+    if (!this.paused) {
+      fn()
+    } else {
+      /* c8 ignore stop */
+      this.#onResume.push(fn)
+    }
+  }
+
+  // do the requisite realpath/stat checking, and return the path
+  // to add or undefined to filter it out.
+  async matchCheck(
+    inPath: Path,
+    ifDir: boolean,
+  ): Promise<Path | undefined> {
+    if (ifDir && this.opts.nodir) return undefined
+    let rpc: Path | undefined
+    let e: Path
+    if (this.opts.realpath) {
+      rpc = inPath.realpathCached() || (await inPath.realpath())
+      if (!rpc) return undefined
+      e = rpc
+    } else {
+      e = inPath
+    }
+    const needStat = e.isUnknown() || this.opts.stat
+    const s = needStat ? await e.lstat() : e
+    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+      const target = await s.realpath()
+      /* c8 ignore start */
+      if (target && (target.isUnknown() || this.opts.stat)) {
+        await target.lstat()
+      }
+      /* c8 ignore stop */
+    }
+    return this.matchCheckTest(s, ifDir)
+  }
+
+  matchCheckTest(e: Path | undefined, ifDir: boolean): Path | undefined {
+    return (
+        e &&
+          (this.maxDepth === Infinity || e.depth() <= this.maxDepth) &&
+          (!ifDir || e.canReaddir()) &&
+          (!this.opts.nodir || !e.isDirectory()) &&
+          (!this.opts.nodir ||
+            !this.opts.follow ||
+            !e.isSymbolicLink() ||
+            !e.realpathCached()?.isDirectory()) &&
+          !this.#ignored(e)
+      ) ?
+        e
+      : undefined
+  }
+
+  matchCheckSync(inPath: Path, ifDir: boolean): Path | undefined {
+    if (ifDir && this.opts.nodir) return undefined
+    let rpc: Path | undefined
+    let e: Path
+    if (this.opts.realpath) {
+      rpc = inPath.realpathCached() || inPath.realpathSync()
+      if (!rpc) return undefined
+      e = rpc
+    } else {
+      e = inPath
+    }
+    const needStat = e.isUnknown() || this.opts.stat
+    const s = needStat ? e.lstatSync() : e
+    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+      const target = s.realpathSync()
+      if (target && (target?.isUnknown() || this.opts.stat)) {
+        target.lstatSync()
+      }
+    }
+    return this.matchCheckTest(s, ifDir)
+  }
+
+  abstract matchEmit(p: Result<O>): void
+  abstract matchEmit(p: string | Path): void
+
+  matchFinish(e: Path, absolute: boolean) {
+    if (this.#ignored(e)) return
+    this.#matchEmitChecked(e, absolute)
+  }
+
+  // emit a match that is known to not be seen or ignored yet
+  #matchEmitChecked(e: Path, absolute: boolean) {
+    // we know we have an ignore if this is false, but TS doesn't
+    if (!this.includeChildMatches && this.#ignore?.add) {
+      const ign = `${e.relativePosix()}/**`
+      this.#ignore.add(ign)
+    }
+    const abs =
+      this.opts.absolute === undefined ? absolute : this.opts.absolute
+    this.seen.add(e)
+    const mark = this.opts.mark && e.isDirectory() ? this.#sep : ''
+    // ok, we have what we need!
+    if (this.opts.withFileTypes) {
+      this.matchEmit(e)
+    } else if (abs) {
+      const abs = this.opts.posix ? e.fullpathPosix() : e.fullpath()
+      this.matchEmit(abs + mark)
+    } else {
+      const rel = this.opts.posix ? e.relativePosix() : e.relative()
+      const pre =
+        this.opts.dotRelative && !rel.startsWith(`..${this.#sep}`) ?
+          `.${this.#sep}`
+        : ''
+      this.matchEmit(!rel ? `.${mark}` : pre + rel + mark)
+    }
+  }
+
+  async match(e: Path, absolute: boolean, ifDir: boolean): Promise<void> {
+    const p = await this.matchCheck(e, ifDir)
+    if (p) this.matchFinish(p, absolute)
+  }
+
+  matchSync(e: Path, absolute: boolean, ifDir: boolean): void {
+    // matchCheckSync just checked that it is not seen or ignored, and
+    // nothing can have changed since
+    const p = this.matchCheckSync(e, ifDir)
+    if (p) this.#matchEmitChecked(p, absolute)
+  }
+
+  walkCB(target: Path, patterns: Pattern[], cb: () => unknown) {
+    /* c8 ignore start */
+    if (this.signal?.aborted) return cb()
+    /* c8 ignore stop */
+    this.walkCB2(target, patterns, new Processor(this.opts), cb)
+  }
+
+  walkCB2(
+    target: Path,
+    patterns: Pattern[],
+    processor: Processor,
+    cb: () => unknown,
+  ) {
+    if (this.#childrenIgnored(target)) return cb()
+    if (this.signal?.aborted) return cb()
+    if (this.paused) {
+      this.onResume(() => this.walkCB2(target, patterns, processor, cb))
+      return
+    }
+    processor.processPatterns(target, patterns)
+
+    // done processing.  all of the above is sync, can be abstracted out.
+    // subwalks is a map of paths to the entry filters they need
+    // matches is a map of paths to [absolute, ifDir] tuples.
+    let tasks = 1
+    const next = () => {
+      if (--tasks === 0) cb()
+    }
+
+    for (const [m, n] of processor.matches.store) {
+      if (this.#ignored(m)) continue
+      tasks++
+      void this.match(m, !!(n & ABSOLUTE), !!(n & IF_DIR)).then(() =>
+        next(),
+      )
+    }
+
+    for (const t of processor.subwalkTargets()) {
+      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+        continue
+      }
+      tasks++
+      const childrenCached = t.readdirCached()
+      if (t.calledReaddir())
+        this.walkCB3(t, childrenCached, processor, next)
+      else {
+        t.readdirCB(
+          (_, entries) => this.walkCB3(t, entries, processor, next),
+          true,
+        )
+      }
+    }
+
+    next()
+  }
+
+  walkCB3(
+    target: Path,
+    entries: Path[],
+    processorx: Processor,
+    cb: () => unknown,
+  ) {
+    const proc = processorx.filterEntries(target, entries)
+
+    let tasks = 1
+    const next = () => {
+      if (--tasks === 0) cb()
+    }
+
+    for (const [m, n] of proc.matches.store) {
+      if (this.#ignored(m)) continue
+      tasks++
+      void this.match(m, !!(n & ABSOLUTE), !!(n & IF_DIR)).then(() =>
+        next(),
+      )
+    }
+    for (const [target, patterns] of proc.subwalks.entries()) {
+      tasks++
+      this.walkCB2(target, patterns, proc.child(), next)
+    }
+
+    next()
+  }
+
+  walkCBSync(target: Path, patterns: Pattern[], cb: () => unknown) {
+    /* c8 ignore start */
+    if (this.signal?.aborted) return cb()
+    /* c8 ignore stop */
+    this.walkCB2Sync(target, patterns, new Processor(this.opts), cb)
+  }
+
+  walkCB2Sync(
+    target: Path,
+    patterns: Pattern[],
+    processor: Processor,
+    cb: () => unknown,
+  ) {
+    if (this.#childrenIgnored(target)) return cb()
+    if (this.signal?.aborted) return cb()
+    if (this.paused) {
+      this.onResume(() =>
+        this.walkCB2Sync(target, patterns, processor, cb),
+      )
+      return
+    }
+    processor.processPatterns(target, patterns)
+
+    // done processing.  all of the above is sync, can be abstracted out.
+    // subwalks is a map of paths to the entry filters they need
+    // matches is a map of paths to [absolute, ifDir] tuples.
+    let tasks = 1
+    const next = () => {
+      if (--tasks === 0) cb()
+    }
+
+    for (const [m, n] of processor.matches.store) {
+      if (this.#ignored(m)) continue
+      this.matchSync(m, !!(n & ABSOLUTE), !!(n & IF_DIR))
+    }
+
+    for (const t of processor.subwalkTargets()) {
+      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+        continue
+      }
+      tasks++
+      const children = t.readdirSync()
+      this.walkCB3Sync(t, children, processor, next)
+    }
+
+    next()
+  }
+
+  walkCB3Sync(
+    target: Path,
+    entries: Path[],
+    processor: Processor,
+    cb: () => unknown,
+  ) {
+    const proc = processor.filterEntries(target, entries)
+
+    let tasks = 1
+    const next = () => {
+      if (--tasks === 0) cb()
+    }
+
+    for (const [m, n] of proc.matches.store) {
+      if (this.#ignored(m)) continue
+      this.matchSync(m, !!(n & ABSOLUTE), !!(n & IF_DIR))
+    }
+    for (const [target, patterns] of proc.subwalks.entries()) {
+      tasks++
+      this.walkCB2Sync(target, patterns, proc.child(), next)
+    }
+
+    next()
+  }
+}
+
+export class GlobWalker<
+  O extends GlobWalkerOpts = GlobWalkerOpts,
+> extends GlobUtil<O> {
+  // each Path is only emitted once (see GlobUtil.seen), so the results
+  // do not need to be deduped
+  matches: Result<O>[] = []
+
+  constructor(patterns: Pattern[], path: Path, opts: O) {
+    super(patterns, path, opts)
+  }
+
+  matchEmit(e: Result<O>): void {
+    this.matches.push(e)
+  }
+
+  async walk(): Promise<Result<O>[]> {
+    if (this.signal?.aborted) throw this.signal.reason
+    if (this.path.isUnknown()) {
+      await this.path.lstat()
+    }
+    await new Promise((res, rej) => {
+      this.walkCB(this.path, this.patterns, () => {
+        if (this.signal?.aborted) {
+          rej(this.signal.reason)
+        } else {
+          res(this.matches)
+        }
+      })
+    })
+    return this.matches
+  }
+
+  walkSync(): Result<O>[] {
+    if (this.signal?.aborted) throw this.signal.reason
+    if (this.path.isUnknown()) {
+      this.path.lstatSync()
+    }
+    // nothing for the callback to do, because this never pauses
+    this.walkCBSync(this.path, this.patterns, () => {
+      if (this.signal?.aborted) throw this.signal.reason
+    })
+    return this.matches
+  }
+}
+
+export class GlobStream<
+  O extends GlobWalkerOpts = GlobWalkerOpts,
+> extends GlobUtil<O> {
+  results: Minipass<Result<O>, Result<O>>
+
+  constructor(patterns: Pattern[], path: Path, opts: O) {
+    super(patterns, path, opts)
+    this.results = new Minipass<Result<O>, Result<O>>({
+      signal: this.signal,
+      objectMode: true,
+    })
+    this.results.on('drain', () => this.resume())
+    this.results.on('resume', () => this.resume())
+  }
+
+  matchEmit(e: Result<O>): void {
+    this.results.write(e)
+    if (!this.results.flowing) this.pause()
+  }
+
+  stream(): MatchStream<O> {
+    const target = this.path
+    if (target.isUnknown()) {
+      void target.lstat().then(() => {
+        this.walkCB(target, this.patterns, () => this.results.end())
+      })
+    } else {
+      this.walkCB(target, this.patterns, () => this.results.end())
+    }
+    return this.results
+  }
+
+  streamSync(): MatchStream<O> {
+    if (this.path.isUnknown()) {
+      this.path.lstatSync()
+    }
+    this.walkCBSync(this.path, this.patterns, () => this.results.end())
+    return this.results
+  }
+}

package/node_modules/gopd/.eslintrc

@@ -0,0 +1,16 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"rules": {
+		"func-style": [2, "declaration"],
+		"id-length": 0,
+		"multiline-comment-style": 0,
+		"new-cap": [2, {
+			"capIsNewExceptions": [
+				"GetIntrinsic",
+			],
+		}],
+	},
+}

package/node_modules/gopd/.github/FUNDING.yml

@@ -0,0 +1,12 @@
+# These are supported funding model platforms
+
+github: [ljharb]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: npm/gopd
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/node_modules/gopd/CHANGELOG.md

@@ -0,0 +1,45 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v1.2.0](https://github.com/ljharb/gopd/compare/v1.1.0...v1.2.0) - 2024-12-03
+
+### Commits
+
+- [New] add `gOPD` entry point; remove `get-intrinsic` [`5b61232`](https://github.com/ljharb/gopd/commit/5b61232dedea4591a314bcf16101b1961cee024e)
+
+## [v1.1.0](https://github.com/ljharb/gopd/compare/v1.0.1...v1.1.0) - 2024-11-29
+
+### Commits
+
+- [New] add types [`f585e39`](https://github.com/ljharb/gopd/commit/f585e397886d270e4ba84e53d226e4f9ca2eb0e6)
+- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `tape` [`0b8e4fd`](https://github.com/ljharb/gopd/commit/0b8e4fded64397a7726a9daa144a6cc9a5e2edfa)
+- [Dev Deps] update `aud`, `npmignore`, `tape` [`48378b2`](https://github.com/ljharb/gopd/commit/48378b2443f09a4f7efbd0fb6c3ee845a6cabcf3)
+- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`78099ee`](https://github.com/ljharb/gopd/commit/78099eeed41bfdc134c912280483689cc8861c31)
+- [Tests] replace `aud` with `npm audit` [`4e0d0ac`](https://github.com/ljharb/gopd/commit/4e0d0ac47619d24a75318a8e1f543ee04b2a2632)
+- [meta] add missing `engines.node` [`1443316`](https://github.com/ljharb/gopd/commit/14433165d07835c680155b3dfd62d9217d735eca)
+- [Deps] update `get-intrinsic` [`eee5f51`](https://github.com/ljharb/gopd/commit/eee5f51769f3dbaf578b70e2a3199116b01aa670)
+- [Deps] update `get-intrinsic` [`550c378`](https://github.com/ljharb/gopd/commit/550c3780e3a9c77b62565712a001b4ed64ea61f5)
+- [Dev Deps] add missing peer dep [`8c2ecf8`](https://github.com/ljharb/gopd/commit/8c2ecf848122e4e30abfc5b5086fb48b390dce75)
+
+## [v1.0.1](https://github.com/ljharb/gopd/compare/v1.0.0...v1.0.1) - 2022-11-01
+
+### Commits
+
+- [Fix] actually export gOPD instead of dP [`4b624bf`](https://github.com/ljharb/gopd/commit/4b624bfbeff788c5e3ff16d9443a83627847234f)
+
+## v1.0.0 - 2022-11-01
+
+### Commits
+
+- Initial implementation, tests, readme [`0911e01`](https://github.com/ljharb/gopd/commit/0911e012cd642092bd88b732c161c58bf4f20bea)
+- Initial commit [`b84e33f`](https://github.com/ljharb/gopd/commit/b84e33f5808a805ac57ff88d4247ad935569acbe)
+- [actions] add reusable workflows [`12ae28a`](https://github.com/ljharb/gopd/commit/12ae28ae5f50f86e750215b6e2188901646d0119)
+- npm init [`280118b`](https://github.com/ljharb/gopd/commit/280118badb45c80b4483836b5cb5315bddf6e582)
+- [meta] add `auto-changelog` [`bb78de5`](https://github.com/ljharb/gopd/commit/bb78de5639a180747fb290c28912beaaf1615709)
+- [meta] create FUNDING.yml; add `funding` in package.json [`11c22e6`](https://github.com/ljharb/gopd/commit/11c22e6355bb01f24e7fac4c9bb3055eb5b25002)
+- [meta] use `npmignore` to autogenerate an npmignore file [`4f4537a`](https://github.com/ljharb/gopd/commit/4f4537a843b39f698c52f072845092e6fca345bb)
+- Only apps should have lockfiles [`c567022`](https://github.com/ljharb/gopd/commit/c567022a18573aa7951cf5399445d9840e23e98b)

package/node_modules/gopd/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Jordan Harband
+
+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.

package/node_modules/gopd/README.md

@@ -0,0 +1,40 @@
+# gopd <sup>[![Version Badge][npm-version-svg]][package-url]</sup>
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][npm-badge-png]][package-url]
+
+`Object.getOwnPropertyDescriptor`, but accounts for IE's broken implementation.
+
+## Usage
+
+```javascript
+var gOPD = require('gopd');
+var assert = require('assert');
+
+if (gOPD) {
+	assert.equal(typeof gOPD, 'function', 'descriptors supported');
+	// use gOPD like Object.getOwnPropertyDescriptor here
+} else {
+	assert.ok(!gOPD, 'descriptors not supported');
+}
+```
+
+[package-url]: https://npmjs.org/package/gopd
+[npm-version-svg]: https://versionbadg.es/ljharb/gopd.svg
+[deps-svg]: https://david-dm.org/ljharb/gopd.svg
+[deps-url]: https://david-dm.org/ljharb/gopd
+[dev-deps-svg]: https://david-dm.org/ljharb/gopd/dev-status.svg
+[dev-deps-url]: https://david-dm.org/ljharb/gopd#info=devDependencies
+[npm-badge-png]: https://nodei.co/npm/gopd.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/gopd.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/gopd.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=gopd
+[codecov-image]: https://codecov.io/gh/ljharb/gopd/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/ljharb/gopd/
+[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/gopd
+[actions-url]: https://github.com/ljharb/gopd/actions

package/node_modules/gopd/gOPD.d.ts

@@ -0,0 +1 @@
+export = Object.getOwnPropertyDescriptor;

package/node_modules/gopd/gOPD.js

@@ -0,0 +1,4 @@
+'use strict';
+
+/** @type {import('./gOPD')} */
+module.exports = Object.getOwnPropertyDescriptor;

package/node_modules/gopd/index.d.ts

@@ -0,0 +1,5 @@
+declare function gOPD<O extends object, K extends keyof O>(obj: O, prop: K): PropertyDescriptor | undefined;
+
+declare const fn: typeof gOPD | undefined | null;
+
+export = fn;

package/node_modules/gopd/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/** @type {import('.')} */
+var $gOPD = require('./gOPD');
+
+if ($gOPD) {
+	try {
+		$gOPD([], 'length');
+	} catch (e) {
+		// IE 8 has a broken gOPD
+		$gOPD = null;
+	}
+}
+
+module.exports = $gOPD;