@excom/neutron 0.1.0

package/.rush/temp/chunked-rush-logs/neutron.apply-exports.chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: cd \"$RUSH_PROJECT_FOLDER\" && node ../heft-rig/scripts/apply-exports.mjs \n"}

package/.rush/temp/chunked-rush-logs/neutron.build_package-metas.chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs \n"}

package/.rush/temp/operation/apply-exports/all.log

@@ -0,0 +1 @@
+Invoking: cd "$RUSH_PROJECT_FOLDER" && node ../heft-rig/scripts/apply-exports.mjs 

package/.rush/temp/operation/apply-exports/log-chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: cd \"$RUSH_PROJECT_FOLDER\" && node ../heft-rig/scripts/apply-exports.mjs \n"}

package/.rush/temp/operation/apply-exports/state.json

@@ -0,0 +1,3 @@
+{
+  "nonCachedDurationMs": 34.12787900000001
+}

package/.rush/temp/operation/build_package-metas/all.log

@@ -0,0 +1 @@
+Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs 

package/.rush/temp/operation/build_package-metas/log-chunks.jsonl

@@ -0,0 +1 @@
+{"kind":"O","text":"Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs \n"}

package/.rush/temp/operation/build_package-metas/state.json

@@ -0,0 +1,3 @@
+{
+  "nonCachedDurationMs": 100.51614900000004
+}

package/.rush/temp/shrinkwrap-deps.json

@@ -0,0 +1,3 @@
+{
+  "../../packages/neutron": "../../packages/neutron:2ltidcL43Q8EBcT7X0HR04ZwzOZtzgd4fdh0lnnFXxA=:"
+}

package/config/rig.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://developer.microsoft.com/json-schemas/rig-package/rig.schema.json",
+  "rigPackageName": "@excom/heft-rig",
+  "rigProfile": "default"
+}
+

package/index.ts

@@ -0,0 +1,9 @@
+export * from "./src/command";
+export * from "./src/devtools-hook";
+export * from "./src/neutron";
+export * from "./src/neutron-element";
+export * from "./src/neutron-internal";
+export * from "./src/types";
+export * from "./src/utils";
+// Prop-type marker for space-separated token attributes (runtime value: `string[]`).
+export { TokenList } from "@excom/kit-utils";

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@excom/neutron",
+  "version": "0.1.0",
+  "description": "Element factory of the Nucleus Stack — typed custom elements with effect-based lifecycles",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24.13.0"
+  },
+  "type": "module",
+  "dependencies": {
+    "@excom/kit-devtools": "^0.1.0",
+    "@excom/kit-logger": "^0.1.0",
+    "@excom/kit-utils": "^0.1.0"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "@excom/heft-rig": "^0.1.0"
+  },
+  "repository": {
+    "url": "excom-dev/nucleus",
+    "directory": "packages/neutron"
+  },
+  "homepage": "https://github.com/excom-dev/nucleus/tree/main/packages/neutron/support/docs/README.md",
+  "bugs": "https://github.com/excom-dev/nucleus/issues",
+  "keywords": [
+    "Neutron",
+    "neutron",
+    "kit-element-base",
+    "custom-elements",
+    "nucleus-stack"
+  ],
+  "excom": {
+    "packageType": "element-base"
+  },
+  "scripts": {
+    "build": "node node_modules/@excom/heft-rig/scripts/vite-build.mjs",
+    "build:watch": "node node_modules/@excom/heft-rig/scripts/vite-build-watch.mjs",
+    "format": "node node_modules/@excom/heft-rig/scripts/format.mjs",
+    "test": "node node_modules/@excom/heft-rig/scripts/vitest.mjs",
+    "coverage": "node node_modules/@excom/heft-rig/scripts/coverage.mjs",
+    "dev": "node node_modules/@excom/heft-rig/scripts/vite-dev.mjs",
+    "preview": "node node_modules/@excom/heft-rig/scripts/vite-preview.mjs",
+    "build:package-metas": "node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs"
+  }
+}

package/rush-logs/neutron.apply-exports.cache.log

@@ -0,0 +1 @@
+Caching has been disabled for this project's "apply-exports" command.

package/rush-logs/neutron.apply-exports.log

@@ -0,0 +1 @@
+Invoking: cd "$RUSH_PROJECT_FOLDER" && node ../heft-rig/scripts/apply-exports.mjs 

package/rush-logs/neutron.build_package-metas.cache.log

@@ -0,0 +1 @@
+This project does not define the caching behavior of the "build:package-metas" command, so caching has been disabled.

package/rush-logs/neutron.build_package-metas.log

@@ -0,0 +1 @@
+Invoking: node node_modules/@excom/heft-rig/scripts/build-package-metas.mjs 

package/src/command.ts

@@ -0,0 +1,102 @@
+import { KitLogger } from "@excom/kit-logger";
+
+/**
+ * The `command` event an element receives from the HTML Command API — a
+ * `<button command="--verb" commandfor="id">`, `<event-handler
+ * command-name="--verb">`, or a script-built `CommandEvent`. It never
+ * bubbles, is cancelable and composed. `command` is the verb; `source` is
+ * the invoker (the button) or `null`.
+ */
+export type TCommandEvent = Event & {
+  readonly command: string;
+  readonly source: Element | null;
+};
+
+export type CommandInit = {
+  /** Element that receives the command. Defaults to the dispatching element. */
+  target?: Element | null;
+  /** Reported as `event.source`. Defaults to the dispatching element. */
+  source?: Element | null;
+};
+
+/** Arguments of the `command` effect key: `command: ["--fetch", { target }]`. */
+export type CommandArgs = [string, CommandInit?];
+
+export const COMMAND_EVENT = "command";
+
+/**
+ * Custom commands are dashed-idents (`--fetch`), like CSS custom
+ * properties; the platform reserves every other name for built-ins.
+ */
+export const isCustomCommand = (name: unknown): name is string =>
+  typeof name === "string" && /^--\S+$/.test(name);
+
+type CommandEventCtor = new (
+  type: string,
+  init?: EventInit & { command?: string; source?: Element | null }
+) => TCommandEvent;
+
+/**
+ * Build a `command` event. Uses the platform `CommandEvent` when the
+ * browser has one; otherwise a plain `Event` carrying the same two
+ * read-only fields, so `onCommand` handlers run identically either way.
+ */
+export function createCommandEvent(
+  command: string,
+  init: { source?: Element | null } = {}
+): TCommandEvent {
+  const source = init.source ?? null;
+  const eventInit = { bubbles: false, cancelable: true, composed: true };
+  const Ctor = (globalThis as { CommandEvent?: CommandEventCtor }).CommandEvent;
+  if (Ctor) {
+    return new Ctor(COMMAND_EVENT, { ...eventInit, command, source });
+  }
+  const event = new Event(COMMAND_EVENT, eventInit) as TCommandEvent;
+  Object.defineProperties(event, {
+    command: { value: command, enumerable: true },
+    source: { value: source, enumerable: true },
+  });
+  return event;
+}
+
+/**
+ * Invoke `command` on `target`. A custom command (`--verb`) is dispatched
+ * directly and the event is returned. A built-in verb (`show-modal`,
+ * `toggle-popover`, …) can only run through the platform: an invisible
+ * proxy `<button command commandfor>` is clicked and removed, and `null`
+ * is returned (browsers without the Command API log a warning and do
+ * nothing).
+ */
+export function invokeCommand(
+  target: Element,
+  command: string,
+  source: Element | null = null
+): TCommandEvent | null {
+  if (isCustomCommand(command)) {
+    const event = createCommandEvent(command, { source });
+    target.dispatchEvent(event);
+    return event;
+  }
+  const proto = HTMLButtonElement.prototype as { commandForElement?: unknown };
+  if (!("commandForElement" in proto)) {
+    KitLogger.warn(
+      `Command "${command}" needs the HTML Command API (\`commandfor\`), which this browser lacks. Custom commands (\`--name\`) work everywhere.`
+    );
+    return null;
+  }
+  const proxy = target.ownerDocument.createElement(
+    "button"
+  ) as HTMLButtonElement & { commandForElement: Element; command: string };
+  // No attribute writes here: test complexity meters count `setAttribute`.
+  // Detached from any form, the proxy cannot submit, so `type` can stay.
+  proxy.style.display = "none";
+  target.ownerDocument.body.appendChild(proxy);
+  proxy.commandForElement = target;
+  proxy.command = command;
+  try {
+    proxy.click();
+  } finally {
+    proxy.remove();
+  }
+  return null;
+}

package/src/common-element.ts

@@ -0,0 +1,377 @@
+import { CommandArgs, invokeCommand } from "./command";
+import type { NeutronElement as TNeutronElement } from "./neutron-element";
+import type { NeutronInternal as TNeutronInternal } from "./neutron-internal";
+import type {
+  EmitArgs,
+  NativeNElement,
+  RuntimeConfig,
+  SuperAddEventListenerOptions,
+} from "./types";
+import { KitLogger } from "@excom/kit-logger";
+
+const findExistingListenerIndex = (listenerArray, type, fn) => {
+  return listenerArray.findIndex(([t, f]) => t === type && f === fn);
+};
+
+export const deref = <T extends HTMLElement | Node | EventTarget>(
+  el: T | WeakRef<T>
+): T | undefined => {
+  return el instanceof WeakRef ? el.deref() : el;
+};
+
+export const getNamespace = (
+  _element: NativeNElement | HTMLElement | TNeutronElement
+): NativeNElement["_n_"] => {
+  const element = _element as NativeNElement;
+  if (!element._n_) {
+    element._n_ = {
+      element: element,
+      eventListeners: [],
+      disconnectedEventListeners: [],
+      disconnectedBroadcastListeners: [],
+      broadcastListeners: [],
+    };
+  }
+  if (!element._n_.eventListeners) {
+    element._n_.eventListeners = [];
+  }
+  if (!element._n_.broadcastListeners) {
+    element._n_.broadcastListeners = [];
+  }
+  return element._n_;
+};
+
+export const buildEventType = (
+  type: string,
+  ctr: typeof TNeutronInternal | undefined,
+  opts: OptsWithInternal = { _broadcast: false }
+): string => {
+  const config = ctr?.runtimeConfig as RuntimeConfig;
+  if (!opts._broadcast && config?.events?.[type]?.prefixWithTag) {
+    return `${config.tag}-${type}`;
+  } else if (opts._broadcast && config?.broadcasts?.[type]?.prefixWithTag) {
+    return `${config.tag}-${type}`;
+  }
+  return type;
+};
+
+export const BROADCAST_CHANNEL = new EventTarget();
+
+interface OptsWithInternal extends SuperAddEventListenerOptions {
+  _broadcast?: boolean;
+}
+
+const CommonElement = {
+  addListener(_type, fn, _opts: OptsWithInternal = { _broadcast: false }) {
+    const { element, ctr } = getNamespace(this);
+    const type = buildEventType(_type, ctr, _opts);
+
+    // TODO clean up this inconsistent _parent args approach
+    const { _broadcast, target, ...opts } = _opts;
+    const listenerArray = _broadcast
+      ? element._n_.broadcastListeners
+      : element._n_.eventListeners;
+    const foundIndex = findExistingListenerIndex(listenerArray, type, fn);
+    const host = _broadcast ? BROADCAST_CHANNEL : target || element;
+    if (foundIndex < 0) {
+      // first registration of this (type, fn)
+      host.addEventListener.apply(host, [type, fn, opts]);
+      listenerArray.push([
+        type,
+        fn,
+        // @ts-ignore fix weakref typing here
+        {
+          ...opts,
+          ...(target ? { target: new WeakRef(target) } : {}),
+        },
+      ]);
+    }
+    // same fn already listed: leave it
+  },
+
+  addBroadcastListener(type, fn, opts: SuperAddEventListenerOptions = {}) {
+    CommonElement.addListener.apply(this, [
+      type,
+      fn,
+      { ...opts, _broadcast: true },
+    ]);
+  },
+
+  removeListener(_type, fn, _opts: OptsWithInternal = { _broadcast: false }) {
+    const { element, ctr } = getNamespace(this);
+    const type = buildEventType(_type, ctr, _opts);
+
+    const { _broadcast } = _opts;
+
+    const listenerArray = _broadcast
+      ? element._n_.broadcastListeners
+      : element._n_.eventListeners;
+    const foundIndex = findExistingListenerIndex(listenerArray, type, fn);
+    if (foundIndex > -1) {
+      const listenerArgsToRemove = listenerArray[foundIndex];
+      if (!_broadcast) {
+        const host = _opts.target || element;
+        host.removeEventListener.apply(host, listenerArgsToRemove);
+        element._n_.eventListeners = element._n_.eventListeners.filter(
+          ([t, f]) =>
+            !(t === listenerArgsToRemove[0] && f === listenerArgsToRemove[1])
+        );
+      } else {
+        BROADCAST_CHANNEL.removeEventListener.apply(
+          BROADCAST_CHANNEL,
+          listenerArgsToRemove
+        );
+        element._n_.broadcastListeners = element._n_.broadcastListeners.filter(
+          ([t, f]) =>
+            !(t === listenerArgsToRemove[0] && f === listenerArgsToRemove[1])
+        );
+      }
+    }
+  },
+
+  removeBroadcastListener(type, fn, opts: SuperAddEventListenerOptions = {}) {
+    CommonElement.removeListener.apply(this, [
+      type,
+      fn,
+      { ...opts, _broadcast: true },
+    ]);
+  },
+
+  addListeners(...args: [string, Function, OptsWithInternal][]) {
+    args.forEach(([type, listener, options]) =>
+      CommonElement.addListener.apply(this, [type, listener, options])
+    );
+  },
+
+  addBroadcastListeners(
+    ...args: [string, Function, SuperAddEventListenerOptions][]
+  ) {
+    args.forEach(([type, listener, options]) =>
+      CommonElement.addListener.apply(this, [
+        type,
+        listener,
+        { ...(options || {}), _broadcast: true },
+      ])
+    );
+  },
+
+  removeListeners(...args: [string, Function, OptsWithInternal][]) {
+    args.forEach((params) => CommonElement.removeListener.apply(this, params));
+  },
+
+  removeBroadcastListeners(
+    ...args: [string, Function, SuperAddEventListenerOptions][]
+  ) {
+    args.forEach(([type, listener, options]) =>
+      CommonElement.removeListener.apply(this, [
+        type,
+        listener,
+        { ...(options || {}), _broadcast: true },
+      ])
+    );
+  },
+
+  toggleListeners(...args: [string, Function, boolean, OptsWithInternal][]) {
+    args.forEach(([type, listener, toggle, options]) => {
+      const action = toggle ? "addListener" : "removeListener";
+      CommonElement[action].apply(this, [type, listener, options]);
+    });
+  },
+
+  toggleBroadcastListeners(
+    ...args: [string, Function, boolean, SuperAddEventListenerOptions][]
+  ) {
+    args.forEach(([type, listener, toggle, options]) => {
+      const action = toggle ? "addListener" : "removeListener";
+      CommonElement[action].apply(this, [
+        type,
+        listener,
+        { ...(options || {}), _broadcast: true },
+      ]);
+    });
+  },
+
+  removeAllListeners(opts = { _broadcast: false }) {
+    const { element } = getNamespace(this);
+    if (!opts?._broadcast) {
+      element._n_.eventListeners
+        ?.filter((params) =>
+          params?.[2]?.target ? !!deref(params[2].target) : true
+        )
+        ?.forEach((params) =>
+          CommonElement.removeListener.apply(element, [
+            params[0],
+            params[1],
+            {
+              ...params[2],
+              ...(params[2]?.target ? { target: deref(params[2].target) } : {}),
+            },
+          ])
+        );
+    } else {
+      element._n_.broadcastListeners?.forEach((params) =>
+        CommonElement.removeListener.apply(element, [
+          params[0],
+          params[1],
+          { ...(params[2] || {}), _broadcast: true },
+        ])
+      );
+    }
+  },
+
+  removeAllBroadcastListeners() {
+    CommonElement.removeAllListeners.apply(this, [{ _broadcast: true }]);
+  },
+
+  internal_disconnectEventListeners(opts = { _broadcast: false }) {
+    const { element } = getNamespace(this);
+    if (!opts?._broadcast) {
+      element._n_.disconnectedEventListeners = element._n_.eventListeners || [];
+      element._n_.eventListeners
+        ?.filter((params) =>
+          params?.[2]?.target ? !!deref(params[2].target) : true
+        )
+        ?.forEach((params) =>
+          CommonElement.removeListener.apply(element, [
+            params[0],
+            params[1],
+            {
+              ...params[2],
+              ...(params[2]?.target ? { target: deref(params[2].target) } : {}),
+            },
+          ])
+        );
+    } else {
+      element._n_.disconnectedBroadcastListeners =
+        element._n_.broadcastListeners || [];
+      element._n_.broadcastListeners?.forEach((params) =>
+        CommonElement.removeListener.apply(element, [
+          params[0],
+          params[1],
+          { ...(params[2] || {}), _broadcast: true },
+        ])
+      );
+    }
+  },
+  internal_disconnectBroadcastListeners(opts = {}) {
+    CommonElement.internal_disconnectEventListeners.apply(this, [
+      { ...opts, _broadcast: true },
+    ]);
+  },
+
+  internal_reconnectEventListeners(opts = { _broadcast: false }) {
+    const { element } = getNamespace(this);
+    if (!opts?._broadcast) {
+      element._n_.disconnectedEventListeners
+        // `once` is not reconnected: we cannot tell if it already fired
+        ?.filter(
+          (params) =>
+            !params?.[2]?.once &&
+            (params?.[2]?.target ? !!deref(params[2].target) : true)
+        )
+        ?.forEach((params) =>
+          CommonElement.addListener.apply(element, [
+            params[0],
+            params[1],
+            {
+              ...params[2],
+              ...(params[2]?.target ? { target: deref(params[2].target) } : {}),
+            },
+          ])
+        );
+      element._n_.disconnectedEventListeners = [];
+    } else {
+      element._n_.disconnectedBroadcastListeners
+        ?.filter((params) => !params?.[2]?.once)
+        ?.forEach((params) =>
+          CommonElement.addListener.apply(element, [
+            params[0],
+            params[1],
+            { ...(params[2] || {}), _broadcast: true },
+          ])
+        );
+      element._n_.disconnectedBroadcastListeners = [];
+    }
+  },
+  internal_reconnectBroadcastListeners(opts = {}) {
+    CommonElement.internal_reconnectEventListeners.apply(this, [
+      { ...opts, _broadcast: true },
+    ]);
+  },
+
+  emit(
+    _type: EmitArgs[0],
+    eventInitObj: EmitArgs[1] = {},
+    opts = { _broadcast: false }
+  ) {
+    const { target, ...eventInit } = eventInitObj;
+    const el = target || this;
+    if (!_type || !el) {
+      throw new Error(
+        `CommonElement.emit: Event target and type are required.`
+      );
+    }
+    const { element, ctr } = getNamespace(el);
+    const type = buildEventType(_type, ctr, opts);
+
+    const event = new CustomEvent(type, {
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+      ...eventInit,
+    });
+    if (!element.isConnected) {
+      KitLogger.warn(
+        `CommonElement.emit: Element is not connected: "${
+          element.localName
+        }". Dispatched ${
+          opts._broadcast ? "broadcast" : "event"
+        } "${type}". This means your element is likely incorrectly emitting events either before connection (possibly eager prop handlers or firing event in .onConstructed()) or after disconnection (possibly due to a lack of cleanup code in .onDisconnected()). Failure to fix this issue may lead to memory leaks or unexpected behavior.`
+      );
+    }
+    (opts._broadcast ? BROADCAST_CHANNEL : element).dispatchEvent(event);
+    return event;
+  },
+
+  emits(...eventConfigs) {
+    const { element } = getNamespace(this);
+    return eventConfigs.map((conf) => CommonElement.emit.apply(element, conf));
+  },
+
+  broadcast(type, eventInitObj = {}) {
+    CommonElement.emit.apply(this, [
+      type,
+      { ...eventInitObj, bubbles: false },
+      { _broadcast: true },
+    ]);
+  },
+
+  broadcasts(...eventConfigs) {
+    const { element } = getNamespace(this);
+    return eventConfigs.map((conf) =>
+      CommonElement.broadcast.apply(element, conf)
+    );
+  },
+
+  /*
+   * Invoke a command: `command: ["--fetch", { target }]`. The element is
+   * the `source` (and the target, when none is given). A `--` command
+   * dispatches a `command` event; a built-in verb goes through a proxy
+   * button (see `invokeCommand`).
+   */
+  command(name: CommandArgs[0], init: CommandArgs[1] = {}) {
+    const { element } = getNamespace(this);
+    const target = init.target || element;
+    const source = init.source === undefined ? element : init.source;
+    return invokeCommand(target, name, source);
+  },
+
+  commands(...commandConfigs: CommandArgs[]) {
+    const { element } = getNamespace(this);
+    return commandConfigs.map((conf) =>
+      CommonElement.command.apply(element, conf)
+    );
+  },
+};
+
+export { CommonElement };

package/src/constants.ts

@@ -0,0 +1,101 @@
+import { CommonElement } from "./common-element";
+import type { DefaultConfig } from "./types";
+import { camelToDash } from "@excom/kit-utils";
+
+const ALWAYS_IGNORE = [undefined, NaN, 0n];
+export const IGNORED_STR_VALUES = [false, 0, ...ALWAYS_IGNORE];
+export const IGNORED_NUM_VALUES = [false, "", ...ALWAYS_IGNORE];
+export const IGNORED_BOOL_VALUES = [0, "", ...ALWAYS_IGNORE];
+export const IGNORED_PROP_VALUES = [0, false, "", ...ALWAYS_IGNORE];
+export const IGNORED_FUNC_VALUES = [null, ...IGNORED_PROP_VALUES];
+export const IGNORED_EFFECTOR_RESULT = [null, ...IGNORED_PROP_VALUES];
+export type IgnoredEffectorResult = void | undefined | null | false | "" | 0;
+
+export const DEFAULT_CONFIG: DefaultConfig = {
+  props: {
+    isMounted: {
+      type: Boolean,
+      notify: false,
+      attr: false,
+    },
+    isAdopted: {
+      type: Boolean,
+      notify: false,
+      attr: false,
+    },
+    wasMounted: {
+      type: Boolean,
+      notify: false,
+      attr: false,
+    },
+    isMoving: {
+      type: Boolean,
+      notify: false,
+      attr: false,
+    },
+    renderRoot: {
+      type: HTMLElement,
+      notify: false,
+      attr: false,
+    },
+  },
+};
+
+export const PROTECTED_PROP_NAMES = [
+  // NeutronInternal statics
+  "builtConfig",
+  "runtimeConfig",
+  "connected",
+  "constructed",
+  "adopted",
+  "error",
+  "propSet",
+  "propUnset",
+  "promiseResolved",
+  "promiseRejected",
+  "disconnected",
+  "broadcast",
+  "event",
+  "eventDefault",
+  "command",
+  "NeutronElement",
+  "CustomElement",
+  // NeutronElement instances
+  "element",
+  "ctr",
+  "eventListeners",
+  "disconnectedEventListeners",
+  "broadcastListeners",
+  "disconnectedBroadcastListeners",
+  "props",
+  "propStore",
+  "queueManager",
+  "debug",
+  // CommonElement keys
+  ...Object.keys(CommonElement),
+  // custom-element statics
+  "observedAttributes",
+  "NeutronInternal",
+  // custom-element instances
+  "_n_",
+  "_q_",
+  "connectedCallback",
+  "adoptedCallback",
+  "disconnectedCallback",
+  "attributeChangedCallback",
+  ...Object.keys(DEFAULT_CONFIG.props),
+  // Other
+  "returns",
+  // `content` is too generic; Quark and CSS already use it for children.
+  "content",
+];
+
+export const PROTECTED_ATTR_NAMES = [
+  /^q-/,
+  /^n-/,
+  /^on-/,
+  /^off-/,
+  ...PROTECTED_PROP_NAMES.map((p) => new RegExp(`^${camelToDash(p)}$`)),
+];
+
+export const PROPS_TO_DEEP_MERGE = ["style"];