diff --git a/README.md b/README.md
index ee38acc..f8081a0 100644
--- a/README.md
+++ b/README.md
@@ -161,7 +161,7 @@ relay.get('option')   // specific key
 
 ### Toggle
 
-Checkbox in the settings panel with cookie persistence.
+Checkbox in the User Settings panel with cookie persistence (per-user, per-pad).
 
 ```js
 const {toggle} = require('ep_plugin_helpers');
@@ -180,6 +180,64 @@ const state = myToggle.init(); // reads cookie, binds checkbox
 // state.enabled tracks current value
 ```
 
+### PadToggle
+
+Parallel checkboxes in **both** the User Settings panel and the Pad Wide Settings panel — matching how native settings (sticky chat, line numbers, etc.) work. The pad-wide value rides Etherpad's existing `padoptions` broadcast/persist rail, so changes propagate to every connected client and are remembered across reloads. The pad creator can `enforceSettings` to lock the user-side checkbox for everyone.
+
+Requires Etherpad with the `ep_*` padOptions passthrough patch (>= 2.7.4). On older cores the pad-wide column is hidden automatically and the user-side cookie toggle keeps working — plugins built on this helper run everywhere.
+
+```js
+const {padToggle} = require('ep_plugin_helpers');
+
+const t = padToggle({
+  pluginName: 'ep_myplugin',          // must match /^ep_[a-z0-9_]+$/
+  settingId: 'my-feature',            // → ids: options-my-feature, padsettings-options-my-feature
+  l10nId: 'ep_myplugin.myFeature',    // i18n key, html10n overwrites the fallback
+  defaultLabel: 'My feature',         // a11y fallback — rendered inside <label> so screen readers
+                                      // announce something before html10n loads
+  defaultEnabled: false,              // overridable via settings.json[pluginName].defaultEnabled
+});
+
+// Server-side hooks
+exports.loadSettings           = t.loadSettings;
+exports.clientVars             = t.clientVars;
+exports.eejsBlock_mySettings   = t.eejsBlock_mySettings;
+exports.eejsBlock_padSettings  = t.eejsBlock_padSettings;
+
+// Client-side hooks
+exports.postAceInit = (hook, ctx) => {
+  const state = t.init({
+    onChange: (enabled) => {
+      // fires on initial load AND whenever the effective value changes
+      enabled ? myFeature.enable() : myFeature.disable();
+    },
+  });
+  // state.getEnabled() returns the current effective value
+};
+exports.handleClientMessage_CLIENT_MESSAGE = t.handleClientMessage_CLIENT_MESSAGE;
+```
+
+The plugin's `ep.json` must list each hook on the right side:
+
+```json
+{
+  "hooks": {
+    "loadSettings": "ep_myplugin",
+    "clientVars": "ep_myplugin",
+    "eejsBlock_mySettings": "ep_myplugin",
+    "eejsBlock_padSettings": "ep_myplugin"
+  },
+  "client_hooks": {
+    "postAceInit": "ep_myplugin/static/js/index",
+    "handleClientMessage_CLIENT_MESSAGE": "ep_myplugin/static/js/index"
+  }
+}
+```
+
+**Effective value rules** (returned by `init`'s `onChange` and `getEnabled`):
+- `enforceSettings` on → use the pad-wide value
+- `enforceSettings` off → use the user cookie value, falling back to pad-wide, falling back to `defaultEnabled`
+
 ### Message Relay
 
 Intercept and relay real-time COLLABROOM messages.
@@ -245,6 +303,7 @@ Old function names still work as aliases:
 | `rawHTML` | `eejsBlock.raw` |
 | `settings` | `createSettingsRelay` |
 | `toggle` | `createSettingsToggle` |
+| `padToggle` | `createPadToggle` |
 | `messageRelay` | `createMessageRelay` |
 | `logger` | `createLogger` |
 
diff --git a/index.js b/index.js
index 3b71459..bcdf0e9 100644
--- a/index.js
+++ b/index.js
@@ -19,6 +19,16 @@ module.exports = {
   // Toggle — checkbox in settings panel with cookie persistence
   get toggle() { return require('./settings-toggle').toggle; },
 
+  // PadToggle — parallel User Settings + Pad Wide Settings checkboxes,
+  // matching native Etherpad behavior. Pad-wide value rides the existing
+  // padoptions broadcast/persist rail; degrades gracefully on cores that
+  // lack the ep_* passthrough patch (Etherpad < 2.7.4).
+  //
+  // Server side ONLY here. Client code must import the sub-path
+  // 'ep_plugin_helpers/pad-toggle' directly to avoid pulling settings-toggle
+  // and other server-only modules into the client bundle.
+  get padToggle() { return require('./pad-toggle-server').padToggle; },
+
   // Messages — intercept and relay real-time messages
   get messageRelay() { return require('./message-relay').messageRelay; },
 
diff --git a/package.json b/package.json
index 8a79b42..7b3e508 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ep_plugin_helpers",
-  "version": "0.2.9",
+  "version": "0.3.0",
   "description": "Shared factory functions to eliminate boilerplate across Etherpad plugins",
   "author": {
     "name": "John McLear",
diff --git a/pad-toggle-server.js b/pad-toggle-server.js
new file mode 100644
index 0000000..d8d7065
--- /dev/null
+++ b/pad-toggle-server.js
@@ -0,0 +1,111 @@
+'use strict';
+
+// padToggle (server side) — emits parallel checkboxes in the User Settings
+// (mySettings) and Pad Wide Settings (padSettings) panels, mirroring native
+// Etherpad behavior. Pad-wide values ride the existing padoptions COLLABROOM
+// rail (stored at pad.padOptions[pluginName] = {enabled: bool}) when the core
+// has the ep_* passthrough patch (Etherpad >= 2.7.4); on older cores the
+// pad-wide block silently no-ops and the user-side cookie toggle alone still
+// works.
+//
+// This module is intended for server-side import only. The companion
+// `pad-toggle.js` provides the client-side init/handleClientMessage hooks.
+// They share the same config; plugin authors should use identical
+// `pluginName`, `settingId`, `l10nId`, and `defaultEnabled` on both sides so
+// the checkbox ids and clientVars block line up.
+
+const PLUGIN_NAME_RE = /^ep_[a-z0-9_]+$/;
+
+let padOptionsPluginPassthrough = false;
+try {
+  // The require lands on a leaf module on patched cores (Etherpad >= 2.7.4)
+  // and throws on older cores. Server-only: this file is never bundled for
+  // the browser, so esbuild's static analysis does not run here.
+  // eslint-disable-next-line global-require
+  const caps = require('ep_etherpad-lite/node/utils/PluginCapabilities');
+  padOptionsPluginPassthrough = caps && caps.padOptionsPluginPassthrough === true;
+} catch (_e) { /* older core — leave as false */ }
+
+const HTML_ESCAPE_RE = /[&<>"']/g;
+const HTML_ESCAPES = {'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'};
+const escapeHtml = (s) => String(s).replace(HTML_ESCAPE_RE, (c) => HTML_ESCAPES[c]);
+
+const validateConfig = (config) => {
+  if (!config || typeof config !== 'object') {
+    throw new Error('padToggle requires a config object');
+  }
+  const {pluginName, settingId, l10nId, defaultLabel, defaultEnabled = true} = config;
+  if (!PLUGIN_NAME_RE.test(pluginName || '')) {
+    throw new Error(
+        `padToggle pluginName must match /^ep_[a-z0-9_]+$/, got: ${pluginName}`);
+  }
+  if (!settingId || typeof settingId !== 'string') {
+    throw new Error('padToggle requires settingId (string)');
+  }
+  if (!l10nId || typeof l10nId !== 'string') {
+    throw new Error('padToggle requires l10nId (string) — i18n is mandatory');
+  }
+  if (!defaultLabel || typeof defaultLabel !== 'string') {
+    throw new Error(
+        'padToggle requires defaultLabel (string) — accessibility fallback ' +
+        'rendered inside <label> so screen readers announce something before ' +
+        'html10n loads. html10n overwrites it at runtime via data-l10n-id.');
+  }
+  return {pluginName, settingId, l10nId, defaultLabel, defaultEnabled: !!defaultEnabled};
+};
+
+const renderCheckbox = (settingId, l10nId, defaultLabel, idPrefix) =>
+  `<p>` +
+    `<input type="checkbox" id="${idPrefix}options-${settingId}">` +
+    `<label for="${idPrefix}options-${settingId}" ` +
+        `data-l10n-id="${escapeHtml(l10nId)}">${escapeHtml(defaultLabel)}</label>` +
+  `</p>`;
+
+const padToggleServer = (rawConfig) => {
+  const {pluginName, settingId, l10nId, defaultLabel, defaultEnabled} = validateConfig(rawConfig);
+  let cachedDefaultEnabled = defaultEnabled;
+
+  const loadSettings = async (hookName, args) => {
+    const ps = (args && args.settings && args.settings[pluginName]) || {};
+    if (typeof ps.defaultEnabled === 'boolean') cachedDefaultEnabled = ps.defaultEnabled;
+  };
+
+  const clientVars = async (hookName, ctx) => {
+    let initialPadEnabled = cachedDefaultEnabled;
+    try {
+      const padSettings = ctx && ctx.pad && typeof ctx.pad.getPadSettings === 'function'
+        ? ctx.pad.getPadSettings() : null;
+      const stored = padSettings && padSettings[pluginName];
+      if (stored && typeof stored.enabled === 'boolean') initialPadEnabled = stored.enabled;
+    } catch (_e) { /* leave initialPadEnabled at instance default */ }
+
+    return {
+      ep_plugin_helpers: {
+        padToggle: {
+          [pluginName]: {
+            padWideSupported: padOptionsPluginPassthrough,
+            settingId,
+            l10nId,
+            defaultEnabled: cachedDefaultEnabled,
+            initialPadEnabled,
+          },
+        },
+      },
+    };
+  };
+
+  const eejsBlock_mySettings = (hookName, args, cb) => {
+    args.content += renderCheckbox(settingId, l10nId, defaultLabel, '');
+    return cb();
+  };
+
+  const eejsBlock_padSettings = (hookName, args, cb) => {
+    if (!padOptionsPluginPassthrough) return cb();
+    args.content += renderCheckbox(settingId, l10nId, defaultLabel, 'padsettings-');
+    return cb();
+  };
+
+  return {loadSettings, clientVars, eejsBlock_mySettings, eejsBlock_padSettings};
+};
+
+module.exports = {padToggle: padToggleServer, createPadToggle: padToggleServer};
diff --git a/pad-toggle.js b/pad-toggle.js
new file mode 100644
index 0000000..58ece94
--- /dev/null
+++ b/pad-toggle.js
@@ -0,0 +1,188 @@
+'use strict';
+
+// padToggle (client side) — wires up the parallel User Settings / Pad Wide
+// Settings checkboxes that pad-toggle-server.js renders. Reads the helper's
+// clientVars block (capability flag + initial pad-wide value), persists the
+// per-user choice in padcookie, and forwards pad-wide changes through the
+// native pad.changePadOption() flow so they ride the existing padoptions
+// COLLABROOM broadcast.
+//
+// This file deliberately has no top-level requires that touch server-only
+// modules — esbuild bundles it into the browser pad bundle, and any
+// node-only path would break the client build.
+
+const PLUGIN_NAME_RE = /^ep_[a-z0-9_]+$/;
+
+const validateConfig = (config) => {
+  if (!config || typeof config !== 'object') {
+    throw new Error('padToggle requires a config object');
+  }
+  const {pluginName, settingId, l10nId, defaultEnabled = true} = config;
+  if (!PLUGIN_NAME_RE.test(pluginName || '')) {
+    throw new Error(
+        `padToggle pluginName must match /^ep_[a-z0-9_]+$/, got: ${pluginName}`);
+  }
+  if (!settingId || typeof settingId !== 'string') {
+    throw new Error('padToggle requires settingId (string)');
+  }
+  if (!l10nId || typeof l10nId !== 'string') {
+    throw new Error('padToggle requires l10nId (string) — i18n is mandatory');
+  }
+  // Client side does no rendering, but the same validation runs here so an
+  // author who forgets defaultLabel on the client gets the same loud error
+  // as on the server.
+  if (!config.defaultLabel || typeof config.defaultLabel !== 'string') {
+    throw new Error('padToggle requires defaultLabel (string) — a11y fallback for screen readers');
+  }
+  return {pluginName, settingId, l10nId, defaultEnabled: !!defaultEnabled};
+};
+
+const padToggleClient = (rawConfig) => {
+  const {pluginName, settingId, defaultEnabled} = validateConfig(rawConfig);
+  const userCheckboxId = `options-${settingId}`;
+  const padCheckboxId = `padsettings-options-${settingId}`;
+
+  let onChangeCallback = () => {};
+  let lastEffective = null;
+
+  const getPad = () => {
+    if (typeof window === 'undefined') return null;
+    try {
+      // eslint-disable-next-line global-require
+      const m = require('ep_etherpad-lite/static/js/pad');
+      if (m && m.pad) return m.pad;
+    } catch (_e) { /* fall through */ }
+    return window.pad || (window.top && window.top.pad) || null;
+  };
+
+  const getCookie = () => {
+    try {
+      // eslint-disable-next-line global-require
+      return require('ep_etherpad-lite/static/js/pad_cookie').padcookie;
+    } catch (_e) { return null; }
+  };
+
+  const getClientVars = () => {
+    if (typeof window === 'undefined') return null;
+    return window.clientVars || (window.top && window.top.clientVars) || null;
+  };
+
+  const isSupportedClient = () => {
+    const cv = getClientVars();
+    const block = cv && cv.ep_plugin_helpers && cv.ep_plugin_helpers.padToggle &&
+        cv.ep_plugin_helpers.padToggle[pluginName];
+    return !!(block && block.padWideSupported);
+  };
+
+  const readPadValue = () => {
+    const pad = getPad();
+    if (!pad || typeof pad.getPadOptions !== 'function') return undefined;
+    const opts = pad.getPadOptions();
+    const v = opts && opts[pluginName];
+    return (v && typeof v.enabled === 'boolean') ? v.enabled : undefined;
+  };
+
+  const readUserValue = () => {
+    const cookie = getCookie();
+    if (!cookie) return undefined;
+    const pref = cookie.getPref(settingId);
+    return (pref === true || pref === false) ? pref : undefined;
+  };
+
+  const isEnforced = () => {
+    const pad = getPad();
+    return !!(pad && typeof pad.isPadSettingsEnforcedForMe === 'function' &&
+        pad.isPadSettingsEnforcedForMe());
+  };
+
+  const getEffective = () => {
+    if (isEnforced()) {
+      const padVal = readPadValue();
+      return padVal != null ? padVal : defaultEnabled;
+    }
+    const userVal = readUserValue();
+    if (userVal != null) return userVal;
+    const padVal = readPadValue();
+    return padVal != null ? padVal : defaultEnabled;
+  };
+
+  const refreshUI = () => {
+    const $u = window.$(`#${userCheckboxId}`);
+    const $p = window.$(`#${padCheckboxId}`);
+    const eff = getEffective();
+    const padVal = readPadValue();
+    if ($u.length) {
+      $u.prop('checked', eff);
+      $u.prop('disabled', isEnforced());
+    }
+    if ($p.length && padVal != null) {
+      $p.prop('checked', padVal);
+    }
+    if (eff !== lastEffective) {
+      lastEffective = eff;
+      try { onChangeCallback(eff); } catch (e) { console.error(e); }
+    }
+  };
+
+  const init = (opts = {}) => {
+    onChangeCallback = typeof opts.onChange === 'function' ? opts.onChange : () => {};
+    const pad = getPad();
+    const cookie = getCookie();
+    const $u = window.$(`#${userCheckboxId}`);
+    const $p = window.$(`#${padCheckboxId}`);
+
+    if ($u.length) {
+      $u.prop('checked', getEffective());
+      $u.prop('disabled', isEnforced());
+      $u.on('change', () => {
+        if (isEnforced()) {
+          $u.prop('checked', getEffective());
+          return;
+        }
+        const v = $u.is(':checked');
+        if (cookie) cookie.setPref(settingId, v);
+        refreshUI();
+      });
+    }
+
+    if ($p.length && pad && typeof pad.changePadOption === 'function') {
+      const initial = readPadValue();
+      if (initial != null) $p.prop('checked', initial);
+      $p.on('change', () => {
+        const v = $p.is(':checked');
+        pad.changePadOption(pluginName, {enabled: v});
+        refreshUI();
+      });
+    } else if (!isSupportedClient()) {
+      if (typeof console !== 'undefined' && !init._warned) {
+        console.warn(
+            `[ep_plugin_helpers.padToggle ${pluginName}] pad-wide settings ` +
+            'unavailable — server lacks ep_* passthrough patch (Etherpad < 2.7.4). ' +
+            'Per-user cookie toggle still works.');
+        init._warned = true;
+      }
+    }
+
+    lastEffective = getEffective();
+    try { onChangeCallback(lastEffective); } catch (e) { console.error(e); }
+
+    return {
+      getEnabled: () => lastEffective,
+      refresh: refreshUI,
+    };
+  };
+
+  // Plugin re-exports this so the helper sees pad-wide broadcasts and
+  // refreshes local state when another user toggles the pad-wide checkbox.
+  // Etherpad dispatches handleClientMessage_<type> for every COLLABROOM
+  // message; for pad-wide changes the outer type is CLIENT_MESSAGE and the
+  // inner payload.type is padoptions.
+  const handleClientMessage_CLIENT_MESSAGE = (hookName, ctx) => {
+    if (!ctx || !ctx.payload) return;
+    if (ctx.payload.type === 'padoptions') refreshUI();
+  };
+
+  return {init, handleClientMessage_CLIENT_MESSAGE};
+};
+
+module.exports = {padToggle: padToggleClient, createPadToggle: padToggleClient};
diff --git a/test/pad-toggle.js b/test/pad-toggle.js
new file mode 100644
index 0000000..962d554
--- /dev/null
+++ b/test/pad-toggle.js
@@ -0,0 +1,159 @@
+'use strict';
+
+const assert = require('assert');
+const {padToggle} = require('../pad-toggle-server');
+
+const baseConfig = () => ({
+  pluginName: 'ep_test',
+  settingId: 'thing',
+  l10nId: 'ep_test.thing',
+  defaultLabel: 'Show Thing',
+});
+
+describe('padToggle', () => {
+  describe('config validation', () => {
+    it('throws when pluginName fails the ep_<lowercase> namespace check', () => {
+      assert.throws(() => padToggle({...baseConfig(), pluginName: 'EP_SHOUTY'}),
+          /pluginName must match/);
+      assert.throws(() => padToggle({...baseConfig(), pluginName: 'ep-dashy'}),
+          /pluginName must match/);
+      assert.throws(() => padToggle({...baseConfig(), pluginName: 'no-prefix'}),
+          /pluginName must match/);
+    });
+
+    it('throws when settingId, l10nId, or defaultLabel is missing', () => {
+      assert.throws(() => padToggle({...baseConfig(), settingId: ''}),
+          /settingId/);
+      assert.throws(() => padToggle({...baseConfig(), l10nId: ''}),
+          /l10nId/);
+      assert.throws(() => padToggle({...baseConfig(), defaultLabel: ''}),
+          /defaultLabel/);
+      assert.throws(() => padToggle({...baseConfig(), defaultLabel: undefined}),
+          /defaultLabel/);
+    });
+
+    it('returns the full server hook surface for valid config', () => {
+      const t = padToggle(baseConfig());
+      for (const k of [
+        'loadSettings', 'clientVars',
+        'eejsBlock_mySettings', 'eejsBlock_padSettings',
+      ]) {
+        assert.strictEqual(typeof t[k], 'function', `missing hook: ${k}`);
+      }
+    });
+
+    it('client sub-path exposes init + handleClientMessage_CLIENT_MESSAGE', () => {
+      const {padToggle: clientFactory} = require('../pad-toggle');
+      const t = clientFactory(baseConfig());
+      assert.strictEqual(typeof t.init, 'function');
+      assert.strictEqual(typeof t.handleClientMessage_CLIENT_MESSAGE, 'function');
+    });
+  });
+
+  describe('eejsBlock_mySettings', () => {
+    it('emits a checkbox with namespaced id, data-l10n-id, and label fallback', (done) => {
+      const t = padToggle(baseConfig());
+      const args = {content: ''};
+      t.eejsBlock_mySettings('hook', args, () => {
+        assert.match(args.content, /id="options-thing"/);
+        assert.match(args.content, /data-l10n-id="ep_test\.thing"/);
+        // a11y fallback: <label> must contain the default text so screen
+        // readers announce something even if html10n hasn't loaded yet.
+        assert.match(args.content, /data-l10n-id="ep_test\.thing">Show Thing<\/label>/);
+        done();
+      });
+    });
+
+    it('HTML-escapes the defaultLabel and l10nId to prevent injection', (done) => {
+      const t = padToggle({
+        ...baseConfig(),
+        defaultLabel: 'A & B <script>',
+        l10nId: 'ep_test.thing"onerror',
+      });
+      const args = {content: ''};
+      t.eejsBlock_mySettings('hook', args, () => {
+        assert.ok(!args.content.includes('<script>'),
+            'raw <script> must not survive into rendered HTML');
+        assert.match(args.content, /A &amp; B &lt;script&gt;/);
+        assert.match(args.content, /data-l10n-id="ep_test\.thing&quot;onerror"/);
+        done();
+      });
+    });
+  });
+
+  describe('eejsBlock_padSettings', () => {
+    it('is a no-op when the core lacks the passthrough patch', (done) => {
+      // Module-level capability detection ran at require time. In this test
+      // env the patched core is not installed, so it stays false — exactly
+      // the unsupported-server scenario the helper is meant to handle.
+      const t = padToggle(baseConfig());
+      const args = {content: ''};
+      t.eejsBlock_padSettings('hook', args, () => {
+        assert.strictEqual(args.content, '',
+            'pad-wide block must not render without core support');
+        done();
+      });
+    });
+  });
+
+  describe('loadSettings', () => {
+    it('honors instance default from settings.json[pluginName].defaultEnabled', async () => {
+      const t = padToggle({...baseConfig(), defaultEnabled: false});
+      await t.loadSettings('h', {settings: {ep_test: {defaultEnabled: true}}});
+      // Verify by reading clientVars seeded value.
+      const cv = await t.clientVars('h', {pad: null});
+      assert.strictEqual(
+          cv.ep_plugin_helpers.padToggle.ep_test.defaultEnabled, true);
+    });
+
+    it('falls back to the constructor default when settings.json is silent', async () => {
+      const t = padToggle({...baseConfig(), defaultEnabled: false});
+      await t.loadSettings('h', {settings: {}});
+      const cv = await t.clientVars('h', {pad: null});
+      assert.strictEqual(
+          cv.ep_plugin_helpers.padToggle.ep_test.defaultEnabled, false);
+    });
+  });
+
+  describe('clientVars', () => {
+    it('namespaces under ep_plugin_helpers.padToggle.<pluginName>', async () => {
+      const t = padToggle(baseConfig());
+      const cv = await t.clientVars('h', {pad: null});
+      assert.ok(cv.ep_plugin_helpers);
+      assert.ok(cv.ep_plugin_helpers.padToggle);
+      assert.ok(cv.ep_plugin_helpers.padToggle.ep_test);
+    });
+
+    it('reports padWideSupported=false in this test env (no patched core)', async () => {
+      const t = padToggle(baseConfig());
+      const cv = await t.clientVars('h', {pad: null});
+      assert.strictEqual(
+          cv.ep_plugin_helpers.padToggle.ep_test.padWideSupported, false);
+    });
+
+    it('reads stored pad-wide value from pad.getPadSettings()[pluginName]', async () => {
+      const t = padToggle({...baseConfig(), defaultEnabled: false});
+      const fakePad = {
+        getPadSettings: () => ({ep_test: {enabled: true}}),
+      };
+      const cv = await t.clientVars('h', {pad: fakePad});
+      assert.strictEqual(
+          cv.ep_plugin_helpers.padToggle.ep_test.initialPadEnabled, true);
+    });
+
+    it('falls back to instance default when pad has no stored value', async () => {
+      const t = padToggle({...baseConfig(), defaultEnabled: true});
+      const fakePad = {getPadSettings: () => ({})};
+      const cv = await t.clientVars('h', {pad: fakePad});
+      assert.strictEqual(
+          cv.ep_plugin_helpers.padToggle.ep_test.initialPadEnabled, true);
+    });
+  });
+
+  describe('backwards-compat alias', () => {
+    it('createPadToggle resolves on both sub-paths', () => {
+      assert.strictEqual(typeof require('../pad-toggle-server').createPadToggle, 'function');
+      assert.strictEqual(typeof require('../pad-toggle').createPadToggle, 'function');
+    });
+  });
+});